Hướng dẫn logarithmic regression python sklearn - hồi quy logarit python sklearn

1.10.1. Phân loại %Classification¶

>>> from sklearn import tree
>>> X = [[0, 0], [1, 1]]
>>> Y = [0, 1]
>>> clf = tree.DecisionTreeClassifier()
>>> clf = clf.fit(X, Y)

Cũng như các phân loại khác,

>>> from sklearn import tree
>>> X = [[0, 0], [1, 1]]
>>> Y = [0, 1]
>>> clf = tree.DecisionTreeClassifier()
>>> clf = clf.fit(X, Y)

>>> from sklearn import tree
>>> X = [[0, 0], [1, 1]]
>>> Y = [0, 1]
>>> clf = tree.DecisionTreeClassifier()
>>> clf = clf.fit(X, Y)

>>> from sklearn import tree
>>> X = [[0, 0], [1, 1]]
>>> Y = [0, 1]
>>> clf = tree.DecisionTreeClassifier()
>>> clf = clf.fit(X, Y)

>>> from sklearn import tree
>>> X = [[0, 0], [1, 1]]
>>> Y = [0, 1]
>>> clf = tree.DecisionTreeClassifier()
>>> clf = clf.fit(X, Y)

Sau khi được trang bị, mô hình sau đó có thể được sử dụng để dự đoán lớp mẫu:

>>> clf.predict([[2., 2.]])
array([1])

Trong trường hợp có nhiều lớp có cùng xác suất và cao nhất, trình phân loại sẽ dự đoán lớp có chỉ số thấp nhất trong số các lớp đó.

Thay thế cho việc xuất ra một lớp cụ thể, xác suất của mỗi lớp có thể được dự đoán, đó là một phần của các mẫu đào tạo của lớp trong một chiếc lá:

>>> clf.predict_proba([[2., 2.]])
array([[0., 1.]])

>>> from sklearn import tree
>>> X = [[0, 0], [1, 1]]
>>> Y = [0, 1]
>>> clf = tree.DecisionTreeClassifier()
>>> clf = clf.fit(X, Y)

Sử dụng bộ dữ liệu IRIS, chúng ta có thể xây dựng một cây như sau:

>>> from sklearn.datasets import load_iris
>>> from sklearn import tree
>>> iris = load_iris()
>>> X, y = iris.data, iris.target
>>> clf = tree.DecisionTreeClassifier()
>>> clf = clf.fit(X, y)

Sau khi được đào tạo, bạn có thể vẽ cây với chức năng

>>> from sklearn import tree
>>> X = [[0, 0], [1, 1]]
>>> Y = [0, 1]
>>> clf = tree.DecisionTreeClassifier()
>>> clf = clf.fit(X, Y)

>>> tree.plot_tree(clf)
[...]

Chúng ta cũng có thể xuất cây theo định dạng GraphViz bằng cách sử dụng nhà xuất khẩu

>>> from sklearn import tree
>>> X = [[0, 0], [1, 1]]
>>> Y = [0, 1]
>>> clf = tree.DecisionTreeClassifier()
>>> clf = clf.fit(X, Y)

>>> from sklearn import tree
>>> X = [[0, 0], [1, 1]]
>>> Y = [0, 1]
>>> clf = tree.DecisionTreeClassifier()
>>> clf = clf.fit(X, Y)

Ngoài ra, các nhị phân cho GraphViz có thể được tải xuống từ trang chủ của dự án GraphViz và trình bao bọc Python được cài đặt từ PYPI với

>>> from sklearn import tree
>>> X = [[0, 0], [1, 1]]
>>> Y = [0, 1]
>>> clf = tree.DecisionTreeClassifier()
>>> clf = clf.fit(X, Y)

Dưới đây là một ví dụ xuất khẩu graphviz của cây trên được đào tạo trên toàn bộ bộ dữ liệu IRIS; Các kết quả được lưu trong một tệp đầu ra

>>> from sklearn import tree
>>> X = [[0, 0], [1, 1]]
>>> Y = [0, 1]
>>> clf = tree.DecisionTreeClassifier()
>>> clf = clf.fit(X, Y)

>>> import graphviz 
>>> dot_data = tree.export_graphviz(clf, out_file=None) 
>>> graph = graphviz.Source(dot_data) 
>>> graph.render("iris") 

Nhà xuất khẩu

>>> from sklearn import tree
>>> X = [[0, 0], [1, 1]]
>>> Y = [0, 1]
>>> clf = tree.DecisionTreeClassifier()
>>> clf = clf.fit(X, Y)

>>> dot_data = tree.export_graphviz(clf, out_file=None, 
...                      feature_names=iris.feature_names,  
...                      class_names=iris.target_names,  
...                      filled=True, rounded=True,  
...                      special_characters=True)  
>>> graph = graphviz.Source(dot_data)  
>>> graph 

Ngoài ra, cây cũng có thể được xuất ở định dạng văn bản với hàm

>>> clf.predict([[2., 2.]])
array([1])

>>> from sklearn.datasets import load_iris
>>> from sklearn.tree import DecisionTreeClassifier
>>> from sklearn.tree import export_text
>>> iris = load_iris()
>>> decision_tree = DecisionTreeClassifier(random_state=0, max_depth=2)
>>> decision_tree = decision_tree.fit(iris.data, iris.target)
>>> r = export_text(decision_tree, feature_names=iris['feature_names'])
>>> print(r)
|--- petal width (cm) <= 0.80
|   |--- class: 0
|--- petal width (cm) >  0.80
|   |--- petal width (cm) <= 1.75
|   |   |--- class: 1
|   |--- petal width (cm) >  1.75
|   |   |--- class: 2

1.10.2. Hồi quy¶Regression¶

Cây quyết định cũng có thể được áp dụng cho các vấn đề hồi quy, sử dụng lớp

>>> clf.predict([[2., 2.]])
array([1])

Như trong cài đặt phân loại, phương thức FIT sẽ lấy làm mảng đối số x và y, chỉ trong trường hợp này Y dự kiến ​​sẽ có các giá trị điểm nổi thay vì các giá trị số nguyên:

>>> from sklearn import tree
>>> X = [[0, 0], [2, 2]]
>>> y = [0.5, 2.5]
>>> clf = tree.DecisionTreeRegressor()
>>> clf = clf.fit(X, y)
>>> clf.predict([[1, 1]])
array([0.5])

1.10.3. Vấn đề đa đầu raMulti-output problems¶

Một vấn đề đa đầu ra là một vấn đề học tập được giám sát với một số đầu ra để dự đoán, đó là khi Y là một mảng 2D của hình dạng

>>> clf.predict([[2., 2.]])
array([1])

Khi không có mối tương quan giữa các đầu ra, một cách rất đơn giản để giải quyết loại vấn đề này là xây dựng n mô hình độc lập, tức là một cho mỗi đầu ra, và sau đó sử dụng các mô hình đó để dự đoán độc lập từng đầu ra. Tuy nhiên, vì có khả năng các giá trị đầu ra liên quan đến cùng một đầu vào có mối tương quan, một cách thường tốt hơn là xây dựng một mô hình duy nhất có khả năng dự đoán đồng thời tất cả các đầu ra. Đầu tiên, nó đòi hỏi thời gian đào tạo thấp hơn vì chỉ có một công cụ ước tính được xây dựng. Thứ hai, độ chính xác tổng quát của công cụ ước tính kết quả thường có thể được tăng lên.

Liên quan đến cây quyết định, chiến lược này có thể dễ dàng được sử dụng để hỗ trợ các vấn đề đa sản lượng. Điều này đòi hỏi các thay đổi sau:

• Lưu trữ n giá trị đầu ra trong lá, thay vì 1;

• Sử dụng các tiêu chí phân tách để tính toán giảm trung bình trên tất cả các đầu ra.

Mô-đun này cung cấp hỗ trợ cho các vấn đề đa đầu ra bằng cách thực hiện chiến lược này trong cả ____10 và

>>> clf.predict([[2., 2.]])
array([1])

>>> clf.predict([[2., 2.]])
array([1])

• Đầu ra N_output giá trị khi

  >>> clf.predict([[2., 2.]])
  array([1])
  

  7;

• Đầu ra Danh sách các mảng N_output của xác suất lớp trên

  >>> clf.predict([[2., 2.]])
  array([1])
  

  8.

Việc sử dụng các cây đa đầu ra để hồi quy được thể hiện trong hồi quy cây quyết định đa đầu ra. Trong ví dụ này, đầu vào x là một giá trị thực duy nhất và đầu ra y là sin và cosin của X.Multi-output Decision Tree Regression. In this example, the input X is a single real value and the outputs Y are the sine and cosine of X.

Việc sử dụng các cây nhiều đầu ra để phân loại được thể hiện khi hoàn thành khuôn mặt với các công cụ ước tính nhiều đầu ra. Trong ví dụ này, các đầu vào X là các pixel của nửa trên của mặt và đầu ra y là các pixel của nửa dưới của các khuôn mặt đó.Face completion with a multi-output estimators. In this example, the inputs X are the pixels of the upper half of faces and the outputs Y are the pixels of the lower half of those faces.

1.10.4. Sự phức tạp trongComplexity¶

Nói chung, chi phí thời gian chạy để xây dựng một cây nhị phân cân bằng là \ (o (n_ {mẫu} n_ {tính năng} \ log (n_ {mẫu })) \). Mặc dù thuật toán xây dựng cây cố gắng tạo ra những cây cân bằng, nhưng chúng sẽ không luôn luôn được cân bằng. Giả sử rằng những người con sẽ được cân bằng xấp xỉ, chi phí ở mỗi nút bao gồm tìm kiếm thông qua \ (O (N_ {tính năng}) \) để tìm tính năng cung cấp mức giảm lớn nhất trong tiêu chí tạp chất, ví dụ: Mất nhật ký (tương đương với mức tăng thông tin). Điều này có chi phí \ (o (n_ {tính năng} n_ {mẫu} \ log (n_ {mẫu})) \) tại mỗi nút, dẫn đến tổng chi phí trên toàn bộ cây (bằng cách tổng chi phí ở mỗi nút) của \ (o (n_ {tính năng} n_ {mẫu}^{2} \ log (n_ {mẫu})) \).\(O(n_{samples}n_{features}\log(n_{samples}))\) and query time \(O(\log(n_{samples}))\). Although the tree construction algorithm attempts to generate balanced trees, they will not always be balanced. Assuming that the subtrees remain approximately balanced, the cost at each node consists of searching through \(O(n_{features})\) to find the feature that offers the largest reduction in the impurity criterion, e.g. log loss (which is equivalent to an information gain). This has a cost of \(O(n_{features}n_{samples}\log(n_{samples}))\) at each node, leading to a total cost over the entire trees (by summing the cost at each node) of \(O(n_{features}n_{samples}^{2}\log(n_{samples}))\).

1.10.5. Mẹo về sử dụng thực tếTips on practical use¶

• Cây quyết định có xu hướng vượt quá dữ liệu với một số lượng lớn các tính năng. Lấy đúng tỷ lệ mẫu so với số lượng tính năng là rất quan trọng, vì một cây có một vài mẫu trong không gian chiều cao rất có khả năng vượt quá.

• Xem xét thực hiện giảm kích thước (PCA, ICA hoặc lựa chọn tính năng) trước để cung cấp cho cây của bạn cơ hội tốt hơn để tìm kiếm các tính năng phân biệt đối xử.PCA, ICA, or Feature selection) beforehand to give your tree a better chance of finding features that are discriminative.

• Hiểu cấu trúc cây quyết định sẽ giúp đạt được nhiều hiểu biết hơn về cách cây quyết định đưa ra dự đoán, điều này rất quan trọng để hiểu các tính năng quan trọng trong dữ liệu. will help in gaining more insights about how the decision tree makes predictions, which is important for understanding the important features in the data.

• Hình dung cây của bạn khi bạn đang đào tạo bằng cách sử dụng chức năng

  >>> clf.predict([[2., 2.]])
  array([1])
  

  9. Sử dụng

  >>> clf.predict_proba([[2., 2.]])
  array([[0., 1.]])
  

  0 làm độ sâu cây ban đầu để cảm nhận về cách cây phù hợp với dữ liệu của bạn, và sau đó tăng độ sâu.

• Hãy nhớ rằng số lượng mẫu cần thiết để điền vào cây nhân đôi cho mỗi cấp độ bổ sung mà cây phát triển. Sử dụng

  >>> clf.predict_proba([[2., 2.]])
  array([[0., 1.]])
  

  1 để kiểm soát kích thước của cây để tránh quá mức.

• Sử dụng

  >>> clf.predict_proba([[2., 2.]])
  array([[0., 1.]])
  

  2 hoặc

  >>> clf.predict_proba([[2., 2.]])
  array([[0., 1.]])
  

  3 để đảm bảo rằng nhiều mẫu thông báo mọi quyết định trong cây, bằng cách kiểm soát phân tách nào sẽ được xem xét. Một số lượng rất nhỏ thường sẽ có nghĩa là cây sẽ vượt quá, trong khi một số lượng lớn sẽ ngăn cây học dữ liệu. Hãy thử

  >>> clf.predict_proba([[2., 2.]])
  array([[0., 1.]])
  

  4 như một giá trị ban đầu. Nếu kích thước mẫu thay đổi rất nhiều, một số float có thể được sử dụng làm tỷ lệ phần trăm trong hai tham số này. Mặc dù

  >>> clf.predict_proba([[2., 2.]])
  array([[0., 1.]])
  

  2 có thể tạo ra những chiếc lá nhỏ tùy ý,

  >>> clf.predict_proba([[2., 2.]])
  array([[0., 1.]])
  

  3 đảm bảo rằng mỗi lá có kích thước tối thiểu, tránh các nút lá không biến đổi thấp, phù hợp trong các vấn đề hồi quy. Để phân loại với một vài lớp,

  >>> clf.predict_proba([[2., 2.]])
  array([[0., 1.]])
  

  7 thường là lựa chọn tốt nhất.

  Lưu ý rằng

  >>> clf.predict_proba([[2., 2.]])
  array([[0., 1.]])
  

  2 xem xét các mẫu trực tiếp và độc lập với

  >>> clf.predict_proba([[2., 2.]])
  array([[0., 1.]])
  

  9, nếu được cung cấp (ví dụ: một nút có các mẫu có trọng số M vẫn được coi là có mẫu M chính xác). Hãy xem xét

  >>> from sklearn.datasets import load_iris
  >>> from sklearn import tree
  >>> iris = load_iris()
  >>> X, y = iris.data, iris.target
  >>> clf = tree.DecisionTreeClassifier()
  >>> clf = clf.fit(X, y)
  

  0 hoặc

  >>> from sklearn.datasets import load_iris
  >>> from sklearn import tree
  >>> iris = load_iris()
  >>> X, y = iris.data, iris.target
  >>> clf = tree.DecisionTreeClassifier()
  >>> clf = clf.fit(X, y)
  

  1 nếu cần tính trọng lượng mẫu khi chia tách.

• Cân bằng bộ dữ liệu của bạn trước khi đào tạo để ngăn cây bị thiên vị đối với các lớp chiếm ưu thế. Cân bằng lớp có thể được thực hiện bằng cách lấy mẫu một số mẫu bằng nhau từ mỗi lớp hoặc tốt nhất là bằng cách bình thường hóa tổng các trọng số mẫu (

  >>> clf.predict_proba([[2., 2.]])
  array([[0., 1.]])
  

  9) cho mỗi lớp thành cùng một giá trị. Cũng lưu ý rằng các tiêu chí cắt tỉa dựa trên trọng lượng, chẳng hạn như

  >>> from sklearn.datasets import load_iris
  >>> from sklearn import tree
  >>> iris = load_iris()
  >>> X, y = iris.data, iris.target
  >>> clf = tree.DecisionTreeClassifier()
  >>> clf = clf.fit(X, y)
  

  0, sau đó sẽ ít bị sai lệch đối với các lớp chiếm ưu thế so với các tiêu chí không nhận thức được trọng lượng mẫu, như

  >>> clf.predict_proba([[2., 2.]])
  array([[0., 1.]])
  

  3.

• Nếu các mẫu có trọng số, sẽ dễ dàng tối ưu hóa cấu trúc cây bằng cách sử dụng tiêu chí cắt trước dựa trên trọng lượng như

  >>> from sklearn.datasets import load_iris
  >>> from sklearn import tree
  >>> iris = load_iris()
  >>> X, y = iris.data, iris.target
  >>> clf = tree.DecisionTreeClassifier()
  >>> clf = clf.fit(X, y)
  

  0, đảm bảo rằng các nút lá chứa ít nhất một phần tổng của trọng lượng mẫu.

• Tất cả các cây quyết định sử dụng

  >>> from sklearn.datasets import load_iris
  >>> from sklearn import tree
  >>> iris = load_iris()
  >>> X, y = iris.data, iris.target
  >>> clf = tree.DecisionTreeClassifier()
  >>> clf = clf.fit(X, y)
  

  6 mảng trong nội bộ. Nếu dữ liệu đào tạo không ở định dạng này, một bản sao của bộ dữ liệu sẽ được thực hiện.

• Nếu ma trận đầu vào X rất thưa thớt, nên chuyển đổi sang thưa thớt

  >>> from sklearn.datasets import load_iris
  >>> from sklearn import tree
  >>> iris = load_iris()
  >>> X, y = iris.data, iris.target
  >>> clf = tree.DecisionTreeClassifier()
  >>> clf = clf.fit(X, y)
  

  7 trước khi gọi FIT và thưa thớt

  >>> from sklearn.datasets import load_iris
  >>> from sklearn import tree
  >>> iris = load_iris()
  >>> X, y = iris.data, iris.target
  >>> clf = tree.DecisionTreeClassifier()
  >>> clf = clf.fit(X, y)
  

  8 trước khi gọi dự đoán. Thời gian đào tạo có thể là các đơn đặt hàng nhanh hơn cho đầu vào ma trận thưa thớt so với ma trận dày đặc khi các tính năng có giá trị bằng không trong hầu hết các mẫu.

1.10.6. Thuật toán cây: ID3, C4.5, C5.0 và Cart¶Tree algorithms: ID3, C4.5, C5.0 and CART¶

Tất cả các thuật toán cây quyết định khác nhau là gì và làm thế nào để chúng khác nhau? Cái nào được thực hiện trong Scikit-learn?

ID3 (Dichotomiser 3) được phát triển vào năm 1986 bởi Ross Quinlan. Thuật toán tạo ra một cây nhiều đường, tìm cho mỗi nút (nghĩa là theo cách tham lam), tính năng phân loại sẽ mang lại mức tăng thông tin lớn nhất cho các mục tiêu phân loại. Cây được trồng theo kích thước tối đa của chúng và sau đó một bước cắt tỉa thường được áp dụng để cải thiện khả năng của cây để khái quát hóa dữ liệu vô hình.

C4.5 là kế thừa của ID3 và loại bỏ các hạn chế rằng các tính năng phải được phân loại bằng cách xác định động một thuộc tính riêng biệt (dựa trên các biến số) phân vùng giá trị thuộc tính liên tục thành một tập hợp các khoảng thời gian riêng biệt. C4.5 chuyển đổi các cây được đào tạo (nghĩa là đầu ra của thuật toán ID3) thành các bộ quy tắc if-then. Độ chính xác của từng quy tắc sau đó được đánh giá để xác định thứ tự mà chúng nên được áp dụng. Việc cắt tỉa được thực hiện bằng cách loại bỏ một điều kiện tiên quyết của quy tắc nếu độ chính xác của quy tắc được cải thiện mà không có nó.

C5.0 là phiên bản mới nhất của Quinlan, theo giấy phép độc quyền. Nó sử dụng ít bộ nhớ hơn và xây dựng các quy tắc nhỏ hơn C4.5 trong khi chính xác hơn.

Giỏ hàng (phân loại và cây hồi quy) rất giống với C4.5, nhưng nó khác nhau ở chỗ nó hỗ trợ các biến mục tiêu số (hồi quy) và không tính toán các bộ quy tắc. Cart xây dựng các cây nhị phân bằng cách sử dụng tính năng và ngưỡng mang lại mức tăng thông tin lớn nhất ở mỗi nút.

Scikit-Learn sử dụng phiên bản tối ưu của thuật toán giỏ hàng; Tuy nhiên, việc triển khai Scikit-LEARN hiện không hỗ trợ các biến phân loại.

1.10.7. Công thức toán họcMathematical formulation¶

Đã cho các vectơ đào tạo \ (x_i \ in r^n \), i = 1,, l, l và một vectơ nhãn \ (y \ in r^l \), một cây quyết định đã phân vùng không gian Cùng một nhãn hoặc giá trị mục tiêu tương tự được nhóm lại với nhau.\(x_i \in R^n\), i=1,…, l and a label vector \(y \in R^l\), a decision tree recursively partitions the feature space such that the samples with the same labels or similar target values are grouped together.

Đặt dữ liệu tại nút \ (m \) được biểu diễn bằng các mẫu \ (q_m \) với \ (n_m \). Đối với mỗi ứng cử viên phân chia \ (\ theta = (j, t_m) \) bao gồm một tính năng \ (j \) và ngưỡng \ (t_m \), phân vùng dữ liệu thành \ (q_m^{trái} (\ theta) \) và \ (q_m^{right} (\ theta) \)\(m\) be represented by \(Q_m\) with \(n_m\) samples. For each candidate split \(\theta = (j, t_m)\) consisting of a feature \(j\) and threshold \(t_m\), partition the data into \(Q_m^{left}(\theta)\) and \(Q_m^{right}(\theta)\) subsets

\] x_j \ leq t_m \} \\ q_m^{right} (\ theta) = q_m \ setMinus q_m^{left} (\ theta)

Chất lượng của sự phân chia ứng cử viên của nút \ (m \) sau đó được tính toán bằng hàm tạp chất hoặc hàm mất \ (h () \), lựa chọn phụ thuộc vào nhiệm vụ được giải quyết (phân loại hoặc hồi quy)\(m\) is then computed using an impurity function or loss function \(H()\), the choice of which depends on the task being solved (classification or regression)

\ [G (q_m, \ theta) = \ frac {n_m^{left}} {n_m} h (q_m^{left} (\ theta)) ^{phải} (\ theta)) \]

Chọn các tham số để giảm thiểu tạp chất

\ [\ theta^* = \ operatorname {argmin} _ \ theta g (q_m, \ theta) \]

Tái phát cho các tập hợp con \ (q_m^{left} (\ theta^*) \) và \ (q_m^{right} (\ theta^*) \) cho đến khi đạt được độ sâu tối đa cho phép } \) hoặc \ (n_m = 1 \).\(Q_m^{left}(\theta^*)\) and \(Q_m^{right}(\theta^*)\) until the maximum allowable depth is reached, \(n_m < \min_{samples}\) or \(n_m = 1\).

>>> clf.predict([[2., 2.]])
array([1])

>>> clf.predict([[2., 2.]])
array([1])

>>> tree.plot_tree(clf)
[...]

1.10.8. Cắt tỉa phức tạp chi phí tối thiểuMinimal Cost-Complexity Pruning¶

Cắt tỉa phức tạp chi phí tối thiểu là một thuật toán được sử dụng để cắt tỉa một cây để tránh quá mức, được mô tả trong Chương 3 của [BRE]. Thuật toán này được tham số hóa bởi \ (\ alpha \ ge0 \) được gọi là tham số độ phức tạp. Tham số độ phức tạp được sử dụng để xác định số đo độ phức tạp chi phí, \ (r_ \ alpha (t) \) của một cây đã cho \ (t \):[BRE]. This algorithm is parameterized by \(\alpha\ge0\) known as the complexity parameter. The complexity parameter is used to define the cost-complexity measure, \(R_\alpha(T)\) of a given tree \(T\):

\ [R_ \ alpha (t) = r (t) + \ alpha | \ widetilde {t} | \]

trong đó \ (| \ widetilde {t} | \) là số lượng nút đầu cuối trong \ (t \) và \ (r (t) \) theo truyền thống được định nghĩa là tổng tốc độ phân loại sai của các nút đầu cuối. Ngoài ra, Scikit-Learn sử dụng tổng số tạp chất có trọng số mẫu của các nút đầu cuối cho \ (r (t) \). Như được hiển thị ở trên, tạp chất của một nút phụ thuộc vào tiêu chí. Cắt tỉa phức tạp chi phí tối thiểu tìm thấy phần cây con của \ (t \) giảm thiểu \ (r_ \ alpha (t) \).\(|\widetilde{T}|\) is the number of terminal nodes in \(T\) and \(R(T)\) is traditionally defined as the total misclassification rate of the terminal nodes. Alternatively, scikit-learn uses the total sample weighted impurity of the terminal nodes for \(R(T)\). As shown above, the impurity of a node depends on the criterion. Minimal cost-complexity pruning finds the subtree of \(T\) that minimizes \(R_\alpha(T)\).

Số đo độ phức tạp chi phí của một nút duy nhất là \ (r_ \ alpha (t) = r (t)+\ alpha \). Chi nhánh, \ (t_t \), được định nghĩa là một cây trong đó nút \ (t \) là gốc của nó. Nói chung, tạp chất của một nút lớn hơn tổng số tạp chất của các nút đầu cuối của nó, \ (r (t_t)\(R_\alpha(t)=R(t)+\alpha\). The branch, \(T_t\), is defined to be a tree where node \(t\) is its root. In general, the impurity of a node is greater than the sum of impurities of its terminal nodes, \(R(T_t). However, the cost complexity measure of a node, \(t\), and its branch, \(T_t\), can be equal depending on \(\alpha\). We define the effective \(\alpha\) of a node to be the value where they are equal, \(R_\alpha(T_t)=R_\alpha(t)\) or \(\alpha_{eff}(t)=\frac{R(t)-R(T_t)}{|T|-1}\). A non-terminal node with the smallest value of \(\alpha_{eff}\) is the weakest link and will be pruned. This process stops when the pruned tree’s minimal \(\alpha_{eff}\) is greater than the

>>> tree.plot_tree(clf)
[...]