English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
مقدمة
تريد الحصول على الميزات الرئيسية للبيانات من الغابة العشوائية
1. النظرية
الغابة العشوائية هي طريقة تعلم آلي متقدمة للغاية، تتمتع بتنوع كبير في التطبيقات، من التسويق إلى التأمين الصحي. يمكن استخدامها لإنشاء نماذج محاكاة للتسويق، وتحليل مصادر العملاء، والاحتفاظ بالمستهلكين وحدهم. يمكن أيضًا استخدامها لتحديد مخاطر الأمراض وتحديد قابلية المرضى للتأثر.
بناءً على طريقة إنشاء معلمات التعلم الذاتي، يمكن تقسيم طرق التعلم المتكامل الحالية إلى فئتين رئيسيتين، وهي وجود علاقة قوية بين معلمات التعلم الذاتي، يجب أن يتم إنشاؤها بشكل سلس، والمعلمات الذاتية التي لا توجد بينها علاقة قوية، يمكن إنشاؤها في نفس الوقت بشكل موازي؛
مثال الأول هو Boosting، ومثال الآخر هو Bagging و "الغابة العشوائية" (Random
Forest)
تضيف الغابة العشوائية في بناء تجمع Bagging على أساس الشجرة القرارية كمعلمين أساسيين، ميزة اختيار العشوائية للميزات في عملية تدريب الشجرة القرارية (أي إدخال اختيار العشوائية للميزات).
ببساطة، الغابة العشوائية هي تجمع للشجر القرارية، ولكن هناك نقاطين مختلفين:
(2) الميزات المختارة بشكل مختلفة: يتم اختيار n ميزات تصنيف للشجرة القرارية من بين جميع الميزات بشكل عشوائي (n هو معامل يجب أن نضبطه نحن)
بسيطاً مفهوم الغابة العشوائية، على سبيل المثال، توقع الراتب، هو بناء عدة أشجار قرار job، age، house، ثم بناءً على خصائص كل من المقدار الذي يتم توقعه (teacher، 39، حي) في قيمة الهدف المتوقعة في كل شجرة قرار (راتب<5000، راتب>=5000)، وبالتالي، تحديد احتمال حدوث المقدار المقدر (مثل، توقع P(rاتب<5000)=0.3).
الغابة العشوائية هي نموذج يمكنه القيام بالتوقع والتصنيف. إنه يمتلك خاصية التعامل مع البيانات الكبيرة، ويساعد في بناء نماذج الأساس للتحليل أو المتغيرات التي هي أساسية.
شرح المعلمات:
أهم اثنين من المعلمات هو n_estimators و max_features.
n_estimators: يمثل عدد الأشجار في الغابة. نظرياً، كلما كان أعلى، كان أفضل. لكن مع ذلك، هناك زيادة في وقت الحساب. لكن ليس كلما كان أعلى، كان أفضل، وسيظهر أفضل تأثير توقع عند عدد معقول من الأشجار.
max_features: اختيار مجموعة فرعية من مجموعة الميزات واستخدامها لقطع العقد. كلما كان عدد المجموعات الفرعية أقل، كان الانحراف أسرع في الحد من الاختلاف، لكن في نفس الوقت، كان الانحراف أسرع في الزيادة. بناءً على الخبرة العملية الجيدة. إذا كان هناك مشكلة توقع، فإن:
max_features = n_features، إذا كان هناك مشكلة تصنيف، فإن max_features = sqrt(n_features).
إذا كنت ترغب في الحصول على نتائج جيدة، لابد من وضع max_depth=None، بالإضافة إلى min_sample_split=1.
بالإضافة إلى ذلك، لابد من تذكر القيام بالتحقق بين التكرارات (التحقق بين التكرارات)، بعيداً عن ذلك، لابد من تذكر في الغابة العشوائية، bootstrap=True. لكن في extra-trees، bootstrap=False.
2. تحقيق الغابة العشوائية باستخدام بايثون
2.1 Demo1
تحقيق وظائف الغابة العشوائية الأساسية
# الغابة العشوائية
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor
import numpy as np
from sklearn.datasets import load_iris
iris=load_iris()
#print iris# الزراعة الاربعة هي: عرض_الزهرة طول_الزهرة عرض_الورقة طول_الورقة والعلامة هي نوع الزهرة: setosa versicolour virginica
print(شكل_الزراعة['الهدف'])
rf = RandomForestRegressor()# تم استخدام إعدادات المعلمات الافتراضية هنا
rf.fit(زراعة_الزهور[:150], زراعة_الزهور[:150])# تدريب النموذج
# اختيار عينتين مختاريتين من النماذج التي تتوقع مختلفة
النموذج = زراعة_الزهور[[100,109]]
print(النموذج)
rf.predict(instance[[0]])
print('instance 0 prediction；',rf.predict(instance[[0]]))
print('instance 1 prediction；',rf.predict(instance[[1]]))
print(iris.target[100],iris.target[109])
运行结果
(150,)
[[ 6.3 3.3 6. 2.5]
[ 7.2 3.6 6.1 2.5]]
instance 0 prediction； [ 2.]
instance 1 prediction； [ 2.]
2 2
2.2 Demo2
3种方法的比较
#random forest test from sklearn.model_selection import cross_val_score from sklearn.datasets import make_blobs from sklearn.ensemble import RandomForestClassifier from sklearn.ensemble import ExtraTreesClassifier from sklearn.tree import DecisionTreeClassifier X, y = make_blobs(n_samples=10000, n_features=10, centers=100,random_state=0) clf = DecisionTreeClassifier(max_depth=None, min_samples_split=2,random_state=0) scores = cross_val_score(clf, X, y) print(scores.mean()) clf = RandomForestClassifier(n_estimators=10, max_depth=None,min_samples_split=2, random_state=0) scores = cross_val_score(clf, X, y) print(scores.mean()) clf = ExtraTreesClassifier(n_estimators=10, max_depth=None,min_samples_split=2, random_state=0) scores = cross_val_score(clf, X, y) print(scores.mean())
نتيجة التشغيل:
0.979408793821
0.999607843137
0.999898989899
2.3 Demo3-تنفيذ اختيار الخصائص
#غابة العشب 2
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor
import numpy as np
from sklearn.datasets import load_iris
iris=load_iris()
from sklearn.model_selection import cross_val_score, ShuffleSplit
X = iris["data"]
Y = iris["target"]
names = iris["feature_names"]
rf = RandomForestRegressor()
scores = []
for i in range(X.shape[1]):
score = cross_val_score(rf, X[:, i:i+1], Y, scoring="r2",
cv=ShuffleSplit(len(X), 3, .3))
scores.append((round(np.mean(score), 3), names[i]))
print(sorted(scores, reverse=True))
نتيجة التشغيل:
[(0.89300000000000002, 'petal width (cm)'), (0.82099999999999995, 'petal length'
(cm)'), (0.13, 'sepal length (cm)'), (-0.79100000000000004, 'sepal width (cm)')]
2.4 demo4-غابة العشب
أردت استخدام الكود التالي لبناء شجرة القرار لغابة العشب،لكن المشكلة التي واجهتها هي أن البرنامج كان يستمر في التشغيل دون الاستجابة،ويجب إصلاح ذلك.
#شجرة القرار لغابة العشب
#coding:utf-8
import csv
from random import seed
from random import randrange
from math import sqrt
def loadCSV(filename):#تحميل البيانات،وضع كل سطر في قائمة
dataSet = []
with open(filename, 'r') as file:
csvReader = csv.reader(file)
for line in csvReader:
dataSet.append(line)
return dataSet
# Convert all columns except the label column to float type
def column_to_float(dataSet):
featLen = len(dataSet[0]) - 1
for data in dataSet:
for column in range(featLen):
data[column] = float(data[column].strip())
# Split the dataset into N pieces for convenience of cross-validation, one piece is the test set, and the other four are training sets
def spiltDataSet(dataSet, n_folds):
fold_size = int(len(dataSet) / n_folds)
dataSet_copy = list(dataSet)
dataSet_spilt = []
for i in range(n_folds):
fold = []
while len(fold) < fold_size: # here you can't use if, if is only effective in the first judgment, while executes the loop until the condition is not met
index = randrange(len(dataSet_copy))
fold.append(dataSet_copy.pop(index)) # pop() function is used to remove an element from a list (by default the last element) and return its value.
dataSet_spilt.append(fold)
return dataSet_spilt
# build data subset
def get_subsample(dataSet, ratio):
subdataSet = []
lenSubdata = round(len(dataSet) * ratio)#returns a floating-point number
while len(subdataSet) < lenSubdata:
index = randrange(len(dataSet) - 1)
subdataSet.append(dataSet[index])
# طباعة طول مجموعة البيانات الفرعية
return subdataSet
# 分割数据集
def data_spilt(dataSet, index, value):
left = []
right = []
for row in dataSet:
إذا كان row[index] < value:
left.append(row)
else:
right.append(row)
return left, right
# 计算分割代价
def spilt_loss(left, right, class_values):
loss = 0.0
للمعلمات في class_values:
left_size = len(left)
if left_size != 0: #防止除数为零
prop = [row[-1] for row in left].count(class_value) / float(left_size)
loss += (prop * (1.0 - prop))
right_size = len(right)
if right_size != 0:
prop = [row[-1] for row in right].count(class_value) / float(right_size)
loss += (prop * (1.0 - prop))
return loss
# 选取任意的n个特征，在这n个特征中，选取分割时的最优特征
def get_best_spilt(dataSet, n_features):
features = []
class_values = list(set(row[-1] for row in dataSet))
b_index, b_value, b_loss, b_left, b_right = 999, 999, 999, None, None
while len(features) < n_features:
index = randrange(len(dataSet[0]) - 1)
if index not in features:
features.append(index)
# print 'features:',features
for index in features:#找到列的最适合做节点的索引，（损失最小）
for row in dataSet:
left, right = data_spilt(dataSet, index, row[index])#以此为节点的，左右分支
loss = spilt_loss(left, right, class_values)
إذا كان loss أقل من b_loss: # البحث عن تكلفة التقسيم الأدنى
b_index, b_value, b_loss, b_left, b_right = index, row[index], loss, left, right
# طباعة b_loss
# طباعة نوع b_index
التراجع = {'index': b_index، 'value': b_value، 'left': b_left، 'right': b_right}
# تحديد علامة الناتج
تعريف decide_label(data):
output = [row[-1] for row in data]
التراجع = أكبر مجموعة (set(output)، مفتاح output.count)
# عملية تقسيم الفرعية، بناء نواة الفروع باستمرار
تعريف sub_spilt(root, n_features, max_depth, min_size, depth):
left = root['left']
# طباعة left
right = root['right']
حذف (root['left'])
حذف (root['right'])
# طباعة depth
if not left or not right:
root['left'] = root['right'] = decide_label(left + right)
# طباعة 'testing'
return
إذا كان depth أكبر من max_depth:
root['left'] = decide_label(left)
root['right'] = decide_label(right)
return
إذا كان طول left أقل من min_size:
root['left'] = decide_label(left)
else:
root['left'] = get_best_spilt(left, n_features)
# طباعة 'testing_left'
sub_spilt(root['left'], n_features, max_depth, min_size, depth + 1)
إذا كان طول right أقل من min_size:
root['right'] = decide_label(right)
else:
root['right'] = get_best_spilt(right, n_features)
# طباعة 'testing_right'
sub_spilt(root['right'], n_features, max_depth, min_size, depth + 1)
# بناء شجرة القرار
def build_tree(dataSet, n_features, max_depth, min_size):
root = get_best_spilt(dataSet, n_features)
sub_spilt(root, n_features, max_depth, min_size, 1)
return root
# التنبؤ بنتائج مجموعة الاختبار
def predict(tree, row):
predictions = []
if row[tree['index']] < tree['value']:
if isinstance(tree['left'], dict):
return predict(tree['left'], row)
else:
return tree['left']
else:
if isinstance(tree['right'], dict):
return predict(tree['right'], row)
else:
return tree['right']
# predictions=set(predictions)
def bagging_predict(trees, row):
predictions = [predict(tree, row) for tree in trees]
return max(set(predictions), key=predictions.count)
# إنشاء غابة عشبية
def random_forest(train, test, ratio, n_feature, max_depth, min_size, n_trees):
trees = []
for i in range(n_trees):
train = get_subsample(train, ratio)# من数据 المقطعة اختيار مجموعة فرعية
tree = build_tree(train, n_features, max_depth, min_size)
# طباعة 'شجرة %d: '%i,tree
trees.append(tree)
# predict_values = [predict(trees,row) for row in test]
predict_values = [bagging_predict(trees, row) for row in test]
return predict_values
# 计算准确率
def accuracy(predict_values, actual):
correct = 0
for i in range(len(actual)):
if actual[i] == predict_values[i]:
correct += 1
return correct / float(len(actual))
if __name__ == '__main__':
seed(1)
dataSet = loadCSV(r'G:\0研究生\tianchiCompetition\训练小样本2.csv')
column_to_float(dataSet)
عدد المناطق = 5
max_depth = 15
min_size = 1
ratio = 1.0
# n_features=sqrt(len(dataSet)-1)
n_features = 15
n_trees = 10
folds = spiltDataSet(dataSet, n_folds)#先是切割数据集
scores = []
للمسلسل fold in folds:
train_set = folds[
:] # 此处不能简单地用train_set=folds，这样用属于引用,那么当train_set的值改变的时候，folds的值也会改变，所以要用复制的形式。（L[:]）能够复制序列，D.copy() 能够复制字典，list能够生成拷贝 list(L)
train_set.remove(fold)#选好训练集
# print len(folds)
train_set = sum(train_set, []) # 将多个fold列表组合成一个train_set列表
# print len(train_set)
test_set = []
للمسلسل row in fold:
row_copy = list(row)
row_copy[-1] = None
test_set.append(row_copy)
# for row in test_set:
# print row[-1]
actual = [row[-1] for row in fold]
predict_values = random_forest(train_set, test_set, ratio, n_features, max_depth, min_size, n_trees)
accur = accuracy(predict_values, actual)
scores.append(accur)
print ('Trees is %d' % n_trees)
print ('scores:%s' % scores)
print ('mean score:%s' % (sum(scores) / float(len(scores))))
2.5 تصنيف بيانات الصوت باستخدام الغابة العشوائية
# CART على مجموعة بيانات ورقة البنك
from random import seed
from random import randrange
من csv import reader
# تحميل ملف CSV
def load_csv(filename):
file = open(filename, "r")
lines = reader(file)
dataset = list(lines)
return dataset
# تحويل عمود النص إلى عدد عشري
def str_column_to_float(dataset, column):
للأسطر في dataset:
row[column] = float(row[column].strip())
# تقسيم مجموعة بيانات إلى k أجزاء
def cross_validation_split(dataset, n_folds):
dataset_split = list()
dataset_copy = list(dataset)
fold_size = int(len(dataset) / n_folds)
for i in range(n_folds):
fold = list()
while len(fold) < fold_size:
index = randrange(len(dataset_copy))
fold.append(dataset_copy.pop(index))
dataset_split.append(fold)
return dataset_split
# احسب نسبة الدقة
def accuracy_metric(actual, predicted):
correct = 0
for i in range(len(actual)):
if actual[i] == predicted[i]:
correct += 1
return correct / float(len(actual)) * 100.0
# تقييم خوارزمية باستخدام تقسيم التحقق من الصحة
def evaluate_algorithm(dataset, algorithm, n_folds, *args):
folds = cross_validation_split(dataset, n_folds)
scores = list()
للمسلسل fold in folds:
train_set = list(folds)
train_set.remove(fold)
train_set = sum(train_set, [])
test_set = list()
للمسلسل row in fold:
row_copy = list(row)
test_set.append(row_copy)
row_copy[-1] = None
predicted = algorithm(train_set, test_set, *args)
actual = [row[-1] for row in fold]
accuracy = accuracy_metric(actual, predicted)
scores.append(accuracy)
عد
# تقسيم مجموعة بيانات بناءً على خاصية وقيمة الخاصية
تعريف test_split(index, value, dataset):
left, right = list(), list()
للأسطر في dataset:
إذا كان row[index] < value:
left.append(row)
else:
right.append(row)
return left, right
# حساب مؤشر Gini لأقسام البيانات
تعريف gini_index(groups, class_values):
gini = 0.0
للمعلمات في class_values:
للمجموعات في groups:
size = len(group)
إذا كان size == 0:
تابع
proportion = [row[-1] for row in group].count(class_value) / float(size)
gini += (proportion * (1.0 - proportion))
تعريف gini
# اختيار أفضل نقطة تقسيم لقاعدة البيانات
تعريف get_split(dataset):
class_values = list(set(row[-1] for row in dataset))
b_index, b_value, b_score, b_groups = 999, 999, 999, None
للمسافات في range(len(dataset[0])-1):
للأسطر في dataset:
groups = test_split(index, row[index], dataset)
gini = gini_index(groups, class_values)
إذا كان gini < b_score:
b_index, b_value, b_score, b_groups = index, row[index], gini, groups
print ({'index':b_index, 'value':b_value})
return {'index':b_index, 'value':b_value, 'groups':b_groups}
# إنشاء قيمة نهاية للعقدة
def to_terminal(group):
outcomes = [row[-1] for row in group]
return max(set(outcomes), key=outcomes.count)
# Create child splits for a node or make terminal
def split(node, max_depth, min_size, depth):
left, right = node['groups']
del(node['groups'])
# check for a no split
if not left or not right:
node['left'] = node['right'] = to_terminal(left + right)
return
# check for max depth
if depth >= max_depth:
node['left'], node['right'] = to_terminal(left), to_terminal(right)
return
# process left child
if len(left) <= min_size:
node['left'] = to_terminal(left)
else:
node['left'] = get_split(left)
split(node['left'], max_depth, min_size, depth+1)
# process right child
if len(right) <= min_size:
node['right'] = to_terminal(right)
else:
node['right'] = get_split(right)
split(node['right'], max_depth, min_size, depth+1)
# بناء شجرة القرار
def build_tree(train, max_depth, min_size):
root = get_split(train)
split(root, max_depth, min_size, 1)
return root
# إجراء توقع باستخدام شجرة القرار
def predict(node, row):
if row[node['index']] < node['value']:
if isinstance(node['left'], dict):
return predict(node['left'], row)
else:
return node['left']
else:
if isinstance(node['right'], dict):
return predict(node['right'], row)
else:
return node['right']
# خوارزمية شجرة التباين والتنبؤ
def decision_tree(train, test, max_depth, min_size):
tree = build_tree(train, max_depth, min_size)
predictions = list()
for row in test:
prediction = predict(tree, row)
predictions.append(prediction)
return(predictions)
# اختبار CART على مجموعة بيانات ورقة البنك
seed(1)
# تحميل وتحضير البيانات
filename = r'G:\0pythonstudy\الشجرة الديناميكية\sonar.all-data.csv'
المجموعة = تحميل_الملف(اسم_الملف)
# تحويل خصائص النص إلى أرقام
للفهم، قم بتنفيذ التمرير عبر القائمة
str_column_to_float(dataset, i)
# تقييم الخوارزمية
عدد المناطق = 5
أعلى عمق = 5
الحجم الأدنى = 10
نقاط = تقييم_الخوارزمية(المجموعة، شجرة القرار، عدد المناطق، أعلى عمق، الحجم الأدنى)
print('النقاط: %s' % نقاط)
print('الدقة المتوسطة: %.3f%%' % (المجموع/عدد النقاط float)))
نتيجة التشغيل:
{'index': 38, 'value': 0.0894}
{'index': 36, 'value': 0.8459}
{'index': 50, 'value': 0.0024}
{'index': 15, 'value': 0.0906}
{'index': 16, 'value': 0.9819}
{'index': 10, 'value': 0.0785}
{'index': 16, 'value': 0.0886}
{'index': 38, 'value': 0.0621}
{'index': 5, 'value': 0.0226}
{'index': 8, 'value': 0.0368}
{'index': 11, 'value': 0.0754}
{'index': 0, 'value': 0.0239}
{'index': 8, 'value': 0.0368}
{'index': 29, 'value': 0.1671}
{'index': 46, 'value': 0.0237}
{'index': 38, 'value': 0.0621}
{'index': 14, 'value': 0.0668}
{'index': 4, 'value': 0.0167}
{'index': 37, 'value': 0.0836}
{'index': 12, 'value': 0.0616}
{'index': 7, 'value': 0.0333}
{'index': 33, 'value': 0.8741}
{'index': 16, 'value': 0.0886}
{'index': 8, 'value': 0.0368}
{'index': 33, 'value': 0.0798}
{'index': 44, 'value': 0.0298}
النقاط: [48.78048780487805, 70.73170731707317, 58.536585365853654, 51.2195121951]
2195, 39.02439024390244]
دقة الوسط: 53.659%
انقر على أي مفتاح للاستمرار. . .
المعرفة:
1. تحميل ملف CSV
من csv import reader # تحميل ملف CSV def load_csv(filename): file = open(filename, "r") lines = reader(file) dataset = list(lines) return dataset filename = r'G:\0pythonstudy\الشجرة الديناميكية\sonar.all-data.csv' dataset=load_csv(filename) print(dataset)
2. تحويل البيانات إلى نموذج float
# تحويل عمود النص إلى عدد عشري def str_column_to_float(dataset, column): للأسطر في dataset: row[column] = float(row[column].strip()) # print(row[column]) # تحويل خصائص النص إلى أرقام للفهم، قم بتنفيذ التمرير عبر القائمة str_column_to_float(dataset, i)
3. تحويل النصوص في العمود الأخير إلى أرقام صحيحة
def str_column_to_int(dataset, column): class_values = [row[column] for row in dataset]# إنشاء قائمة من علامات الفئة # print(class_values) unique = set(class_values)# الحصول على العناصر المختلفة من القائمة print(unique) lookup = dict()# تعريف قائمة # طباعة (enumerate(unique)) للفهم، قم بتنفيذ التمرير عبر قائمة الفئات المميزة lookup[value] = i # print(lookup) للأسطر في dataset: row[column] = lookup[row[column]] print(lookup['M'])
4. تقسيم مجموعة البيانات إلى K أجزاء
# تقسيم مجموعة بيانات إلى k أجزاء def cross_validation_split(dataset, n_folds): dataset_split = list()# إنشاء قائمة فارغة dataset_copy = list(dataset) print(len(dataset_copy)) print(len(dataset)) #print(dataset_copy) fold_size = int(len(dataset) / n_folds) for i in range(n_folds): fold = list() while len(fold) < fold_size: index = randrange(len(dataset_copy)) # print(index) fold.append(dataset_copy.pop(index))# باستخدام .pop() إزالة العنصر من الداخل (مما يعادل الانتقال)، فإن هذه الأجزاء الكاملة مختلفة. dataset_split.append(fold) return dataset_split n_folds=5 folds = cross_validation_split(dataset, n_folds)# مجموعة تدريبية مقسومة إلى k أجزاء مختلفة
5. حساب نسبة الدقة
# احسب نسبة الدقة def accuracy_metric(actual, predicted): correct = 0 for i in range(len(actual)): if actual[i] == predicted[i]: correct += 1 return correct / float(len(actual)) * 100.0# هذه هي معادلة دقة الفئة الثنائية
6. كل عمود في الفئة الثنائية
# تقسيم مجموعة بيانات بناءً على خاصية وقيمة الخاصية تعريف test_split(index, value, dataset): left, right = list(), list()# تعريف قائمتين فارغتين للأسطر في dataset: إذا كان row[index] < value: left.append(row) else: right.append(row) تعريف left, right # تعريف قائمتين فارغتين، كل منهما تقوم بتقسيم السطر المحدد (index) إلى فئتين بناءً على القيمة
استخدم مؤشر Gini للحصول على نقطة تقسيم أفضل
# حساب مؤشر Gini لأقسام البيانات
تعريف gini_index(groups, class_values):
gini = 0.0
للمعلمات في class_values:
للمجموعات في groups:
size = len(group)
إذا كان size == 0:
تابع
proportion = [row[-1] for row in group].count(class_value) / float(size)
gini += (proportion * (1.0 - proportion))
تعريف gini
# اختيار أفضل نقطة تقسيم لقاعدة البيانات
تعريف get_split(dataset):
class_values = list(set(row[-1] for row in dataset))
b_index, b_value, b_score, b_groups = 999, 999, 999, None
للمسافات في range(len(dataset[0])-1):
للأسطر في dataset:
groups = test_split(index, row[index], dataset)
gini = gini_index(groups, class_values)
إذا كان gini < b_score:
b_index, b_value, b_score, b_groups = index, row[index], gini, groups
# print(groups)
print ({'index':b_index, 'value':b_value,'score':gini})
return {'index':b_index, 'value':b_value, 'groups':b_groups}
هذا الكود، في حساب معادلة gini، يطبق التعريف مباشرة، من السهل الفهم. قد يكون الحصول على نقطة القطع الأمثل صعب الفهم، هنا تم استخدام دفعتين من التكرار، دفعة واحدة هي تكرار لأسطر مختلفة، ودفعة أخرى هي تكرار لأعمدة مختلفة. وكل مرة يتم تحديث قيمة المعادلة gini.
8、الشجرة القرار
# Create child splits for a node or make terminal def split(node, max_depth, min_size, depth): left, right = node['groups'] del(node['groups']) # check for a no split if not left or not right: node['left'] = node['right'] = to_terminal(left + right) return # check for max depth if depth >= max_depth: node['left'], node['right'] = to_terminal(left), to_terminal(right) return # process left child if len(left) <= min_size: node['left'] = to_terminal(left) else: node['left'] = get_split(left) split(node['left'], max_depth, min_size, depth+1) # process right child if len(right) <= min_size: node['right'] = to_terminal(right) else: node['right'] = get_split(right) split(node['right'], max_depth, min_size, depth+1)
يستخدم هذا البرنامج البرمجة التكرارية لإنشاء شجرة اليسار واليمن بشكل متكرر.
9. بناء شجرة القرار
# بناء شجرة القرار def build_tree(train, max_depth, min_size): root = get_split(train) split(root, max_depth, min_size, 1) return root tree=build_tree(train_set, max_depth, min_size) print(tree)
10. التنبؤ باستخدام مجموعة test
# بناء شجرة القرار def build_tree(train, max_depth, min_size): root = get_split(train)# الحصول على أفضل نقطة قطع، قيمة المؤشر، groups split(root, max_depth, min_size, 1) return root # tree=build_tree(train_set, max_depth, min_size) # print(tree) # إجراء توقع باستخدام شجرة القرار def predict(node, row): print(row[node['index']]) print(node['value']) if row[node['index']] < node['value']:# استخدم مجموعة الاختبار لتبديل أفضل نقاط القطع التي تم تدريبها، عند وجود تباين في نقاط القطع، قم بالبحث في شجرة اليمين واليسار لتحسين المقارنة. if isinstance(node['left'], dict):# إذا كان النوع دictionary، قم بتنفيذ العملية return predict(node['left'], row) else: return node['left'] else: if isinstance(node['right'], dict): return predict(node['right'], row) else: return node['right'] tree = build_tree(train_set, max_depth, min_size) predictions = list() for row in test_set: prediction = predict(tree, row) predictions.append(prediction)
11. تقييم شجرة القرار
# تقييم خوارزمية باستخدام تقسيم التحقق من الصحة def evaluate_algorithm(dataset, algorithm, n_folds, *args): folds = cross_validation_split(dataset, n_folds) scores = list() للمسلسل fold in folds: train_set = list(folds) train_set.remove(fold) train_set = sum(train_set, []) test_set = list() للمسلسل row in fold: row_copy = list(row) test_set.append(row_copy) row_copy[-1] = None predicted = algorithm(train_set, test_set, *args) actual = [row[-1] for row in fold] accuracy = accuracy_metric(actual, predicted) scores.append(accuracy) عد
هذا هو نهاية محتوى هذا المقال، نأمل أن يكون قد ساعد في تعلمكم، ونأمل أن تحصلوا على الدعم الكبير لمساعدة تعليمات الصراخ.
بيان: محتوى هذا المقال تم جمعه من الإنترنت، حقوق الطبع والنشر مملوكة للمالك الأصلي، تم جمع المحتوى بواسطة مساهمات المستخدمين عبر الإنترنت، لا يمتلك هذا الموقع حقوق الملكية، لم يتم تعديل المحتوى بشكل يدوي، ولا يتحمل هذا الموقع أي مسؤولية قانونية متعلقة بذلك. إذا اكتشفت محتوى يشتبه في انتهاك حقوق الطبع والنشر، فيرجى إرسال بريد إلكتروني إلى: notice#oldtoolbag.com (عند إرسال البريد الإلكتروني، يرجى استبدال #بـ @) لتقديم الشكوى، وتقديم الدليل المتعلق، وسيتم حذف المحتوى المزعوم فور التحقق منه.