Ang mga punong pasiya ay isa sa pinakamadalas gamiting aparato para sa klasipikasyon at regresyon.Ang mga ito ay gumagana sa pamamagitan ng paghahati ng mga datos sa mga sangay batay sa mga katangiang moral, na tinutularan ang paraan ng pagpapasiya ng mga tao. Bagaman ang mga aklatan na gaya ng scikit jart jarning ay gumagawa sa mga punong desisyon na maliit, ang pagpapatupad ng isa mula sa pagkakamot ay isang mahusay na paraan upang maunawaan ng mga baguhan ang mga gawaing alg pang-inuno.Ang pagtuturong ito ay aakay sa iyo sa pamamagitan ng teoriya at kodigo, upang magtayo ka ng iyong sariling puno mula sa lupa.

Ano ba ang Isang Puno ng Pasiya?

Ang isang punong desisyon ay isang istrakturang daloycht role na tulad ng stake na kung saan ang bawat panloob na node ay kumakatawan sa isang pagsubok sa isang katangian (e.g., ⁇ IS) ang edad > 30? ⁇ ), ang bawat sangay ay kumakatawan sa kalalabasan ng pagsubok na iyon, at ang bawat dahon node ay humahawak ng isang tatak ng klase o patuloy na halaga. Ang tunguhin ay ang lumikha ng isang modelo na humuhula ng isang puntiryang pabagu-bago-bago sa pamamagitan ng pag-bago ng mga payak na alituntunin sa desisyon na naka-lipat mula sa mga tampok na datos.Ang mga puno ng pili ay popular dahil ang mga ito ay madaling bigyang pakahulugan at nangangailangan ng kaunting preprocess (nopekwensiyalyon o hindi normal na pag-pag-isip).

Ang puno ay itinatayo muli nang maayos: simula sa ugat, ang algorithm ay pumipili ng pinakamahusay na katangian at split point na naghihiwalay sa data na pinakamalinis.[kailangan ng sanggunian] Ang prosesong ito ay inuulit sa bawat subset hanggang sa matugunan ang isang kondisyong paghinto. Para sa mas maraming background, ang Wikipedia ⁇ s ] Tungkol sa pagkatuto ng puno ng desisyon ay nagbibigay ng isang matatag na regulatoridad.

Mga Concept na Dapat Mong Unawain

Mga Node, Sangay, at mga Dahon

Ang root node ay naglalaman ng buong training dataset. Internal nodes test isang tampok at hinahati ang datos sa dalawa o higit pang mga bata node. Ang mga brandes ay ang mga koneksiyon na kumakatawan sa kinalabasan ng isang pagsubok. Leaf nodes (terminal nodes) output ang pangwakas na prediksiyon – ang pinaka-karaniwang klase sa klasipikasyon o ang meanidad sa regression.

Paghihiwalay ng Criteria

Upang makagawa ng isang punungkahoy, kailangan mo ng isang paraan upang sukatin ang kalidad ng isang potensiyal na hati, ang pinakakaraniwang pamantayan ay:

  • Gini ventitation – ginamit sa klasipikasyon upang sukatin kung gaano kadalas na ang isang elementong randomang pinili ay maling lagurian kung ito ay pasumala ayon sa distribusyon ng mga klase sa subset. Ang Lower Gini ay mas mabuti.
  • Entropy – sukatin ang dami ng sakit o kawalang katiyakan sa isang set. Ang tunguhin ay ang minimise entropy pagkatapos ng split (pagkakamit ng mutasyon).
  • Variance reasure – ginagamit para sa regresyon trees. kinakalkula nito ang pagbabawas ng dibersidad (o mean squared error) na nakakamit ng split.

Sinusuri ng algorithm ang bawat posibleng hati sa bawat bahagi at pinipili ang isa na nagbubunga ng pinakamalaking pagbawas sa karumihan (o pakinabang sa impormasyon).

Pag - unlad at Pagkakamit ng Ratio sa Impormasyon

Ang pagkakamit ng impormasyon ay ang pagkakaiba ng karumihan ng magulang na node at ng pinabigat na halaga ng mga dumi ng bata.Sa simpleng pananalita, ito ay may hilig na pumabor sa mga katangian na may maraming halaga.Ang ratio ng pakinabang (ginamit sa C4.5) ay normalise ito.Para sa tortial na ito ay manghahawakan tayo sa pamantayang impormasyong natamo gamit ang Ginining performance, na siyang default sa CART (Classification and Regression Trees).

Pagtatayo ng Isang Pasiyang Puno Ayon sa Hakbang

1. Ihanda ang Iyong Data

Kailangan mo ng dataset na may mga tampok at target na mga etiketa. Para sa simpleng pananalita, gumamit ng binary classification dataset na may mga katangiang numeriko. Halimbawa:

  • Mga Kaganapan:, Panahon ng Kita
  • [Trat: Sinang-ayunan (1) o Hindi sinasang-ayunan (0)

Linisin ang datos: hawakan ang nawawalang mga halaga, alisin ang mga kopya, at tiyakin ang mga uri ng numero. Ang mga puno ng pilipino ay maaaring humawak ng halo-halong mga uri ng datos ngunit ang weidel ay kumapit sa numeriko para sa pagpapatupad.

2. Ipaliwanag ang Isang Nakakasirang Katuwaan sa Pagpipinta

Aming ipatutupad ang Gini info, at ang indise ng mga bagay ay Gini:

Kung saan ang p i ang proporsiyon ng mga bagay sa klase i. Para sa isang binary split, ang kabuuang Gini ay ang timbang na katamtaman ng bata node.

3. Pag - aalisan ng Bisa

Sa bawat bahagi, tingnan ang mga natatanging halaga. suriin ang bawat posibleng pagsisimula (pagtatantiya sa pagitan ng magkakasunod na pinag-isa-isang mga halaga). sa bawat pasukan ng kandidato, hatiin ang datos sa kaliwa at kanang mga grupo, i-compute ang Gini, at tuntunin ang pinakamahusay na hati.

4. Itayo Nang Paulit - ulit ang Punungkahoy

Gumawa ng isang tungkulin na kumukuha ng isang subset ng datos at isang kasalukuyang lalim. Ito ay sumusuri sa mga paghintong kondisyon (hal.g., sukdulang lalim na naabot, minimum na sampol sa bawat node, o walang nakuhang impormasyong pakinabang). kung matugunan ang isang kondisyon, lumikha ng isang leaf node sa pamamagitan ng karamihang uri. Kung hindi, hanapin ang pinakamahusay na hati at lumikha ng isang panloob na node, pagkatapos ay muling tawagin ang tungkulin sa kaliwa at kanang hati.

5. Gumawa ng mga Hula

Kapag naitayo na ang puno, tuwiran nang sabihin: magsimula sa ugat, sundan ang mga sanga sa pamamagitan ng pagsusuri sa tampok na mga pagsubok sa bagong sampol, at ibalik ang halaga ng dahon na iyong tinalupa.

Buong Implementasyon sa Python

Nasa ibaba ang kumpleto at kaunting pagpapatupad ng isang punong desisyon para sa klasipikasyon gamit ang Gini induct. Ang kodigong ito ay para sa pag-aaral – hindi ito na-publish para sa malalaking datasets.

import numpy as np
from collections import Counter

class DecisionTree:
 def __init__(self, max_depth=None, min_samples_split=2):
 self.max_depth = max_depth
 self.min_samples_split = min_samples_split
 self.tree = None

 def fit(self, X, y):
 dataset = np.column_stack((X, y))
 self.tree = self._grow_tree(dataset)

 def _grow_tree(self, dataset, depth=0):
 X, y = dataset[:, :-1], dataset[:, -1]
 n_samples, n_features = X.shape
 n_labels = len(np.unique(y))

 # Stopping conditions
 if (n_labels == 1 or depth == self.max_depth or n_samples < self.min_samples_split):
 leaf_value = Counter(y).most_common(1)[0][0]
 return {'leaf': True, 'value': leaf_value}

 best_feature, best_threshold = self._best_split(dataset, n_features)
 if best_feature is None:
 leaf_value = Counter(y).most_common(1)[0][0]
 return {'leaf': True, 'value': leaf_value}

 left_idx, right_idx = self._split(dataset[:, best_feature], best_threshold)
 left_subtree = self._grow_tree(dataset[left_idx], depth+1)
 right_subtree = self._grow_tree(dataset[right_idx], depth+1)
 return {'leaf': False,
 'feature': best_feature,
 'threshold': best_threshold,
 'left': left_subtree,
 'right': right_subtree}

 def _best_split(self, dataset, n_features):
 best_gini = float('inf')
 best_feature, best_threshold = None, None
 for feature in range(n_features):
 thresholds = np.unique(dataset[:, feature])
 for i in range(len(thresholds)-1):
 thresh = (thresholds[i] + thresholds[i+1]) / 2
 left_idx, right_idx = self._split(dataset[:, feature], thresh)
 if len(left_idx) == 0 or len(right_idx) == 0:
 continue
 gini = self._gini_gain(dataset, left_idx, right_idx)
 if gini < best_gini:
 best_gini = gini
 best_feature = feature
 best_threshold = thresh
 return best_feature, best_threshold

 def _split(self, values, threshold):
 left_idx = np.where(values <= threshold)[0]
 right_idx = np.where(values > threshold)[0]
 return left_idx, right_idx

 def _gini_gain(self, dataset, left_idx, right_idx):
 total = len(left_idx) + len(right_idx)
 gini_left = self._gini(dataset[left_idx, -1])
 gini_right = self._gini(dataset[right_idx, -1])
 return (len(left_idx)/total) * gini_left + (len(right_idx)/total) * gini_right

 def _gini(self, labels):
 _, counts = np.unique(labels, return_counts=True)
 p = counts / np.sum(counts)
 return 1 - np.sum(p**2)

 def predict(self, X):
 return np.array([self._predict_row(x, self.tree) for x in X])

 def _predict_row(self, x, node):
 if node['leaf']:
 return node['value']
 if x[node['feature']] <= node['threshold']:
 return self._predict_row(x, node['left'])
 else:
 return self._predict_row(x, node['right'])

Pagsubok sa Puno

Gumamit ng simpleng dataset na gaya ng classic iris dataset (dalawang katangian para sa binary classification). [[FLT]] Ang pag-aaral ng kripto na si Iris dataset ay gumagana nang mahusay. Ihambing ang inyong mga treeific sa shikan ng shikant jaleningift upang patunayan ang pagiging tama.

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

data = load_iris()
X = data.data[:100] # take only first two classes (binary)
y = data.target[:100]

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

tree = DecisionTree(max_depth=3)
tree.fit(X_train, y_train)
preds = tree.predict(X_test)
accuracy = np.mean(preds == y_test)
print(f'Accuracy: {accuracy:.2f}')

Patiunang Pamamaraan Upang Pabutihin ang Iyong Puno

Pag - iingat Upang Maiwasang Malabis na Karapat - dapat

Ang isang punong ganap na malaki ay maaaring mag-eemorise ingay sa pagsasanay ng datos. hunning ay nag-aalis ng mga sanga na may kaunting propesyunal na kapangyarihan. ang mga karaniwang pamamaraan ay ang prephypruning (pag-aalis ng paglaki nang maaga sa pamamagitan o ) at post zigrupruning (pag-unlad ng puno pagkatapos ay inaalis ang mga sanga gamit ang isang anciflution set o gastos ng caltexpxity fut). Ang ating pagpapatupad ay sumusuporta na sa preprunning.

Pakikitungo sa mga Katangiang Di - nakapipinsala at Kategorikal

Para sa patuloy na mga katangian, gumamit kami ng mga midpoint sa pagitan ng mga naibubukod na mga halaga bilang mga pasukan. para sa mga katangiang kategorikal (hal., ⁇ Cor = pula/green/blue ⁇ ), ang bawat kategorya ay maaaring maging hiwalay na sanga (madaming categorikal na split) o kaya ay maaari mong bariary calceencode ang mga ito. karamihan sa modernong pagpapatupad (katulad ng scikit quarnowlewlewleachle) ay gumagamit ng mga barients kahit para sa mga categorical fraimpositions.

Pakikitungo sa Nawawalang mga Pamantayan

Ang tunay na data ng mga kriterno ay kadalasang may nawawalang mga pamantayan. Ang simpleng pamamaraan ay magtalaga ng nawawalang mga pamantayan sa pinakamadalas na sangay sa mga sampol ng pagsasanay na may katangian.

Kung Paano Maihahambing sa mga Aklatan at Higit Pang Pagbabasa

Bagaman ang pagtatayo mula sa gasgas ay nakapagtuturo, ang mga sistema sa produksiyon ay gumagamit ng mga aklatan na gaya ng scikit phytopning na naglalaan ng kapaki - pakinabang na mga pagpapatupad ng C.[1].

Pagsasaayos

Sa paggawa ng isang demystipyo ng isang punong degring ay nakakakuha ka ng isa sa pinakamahalagang algorithm sa pagkatuto ng makina. napag-alaman mo kung paanong ang isang simpleng reconstructive reverse na pamamaraan ay maaaring gumawa ng isang malakas na modelo. Sa pamamagitan ng pagsusulat ng code mismo, nagkakaroon ka ng mas malalim na pagkaunawa sa mga pamamaraang fertial, splity selection, at ang pangkalakal na mga transaksyon sa pagitan ng pagkiling at pagkakaiba. Bilang susunod na hakbang, subukan ang pagdaragdag ng regresyon, pagtabas, o paghawak ng mga katangiang categorikal. Ang mga kasanayan dito ay tutulong sa iyo na kumilos sa mas masalimuot na mga paraang enembloidyo na tulad ng mga kagubatan.