मैं वर्तमान में गिनी और सूचना लाभ का उपयोग करके एक निर्णय वृक्ष वर्गीकरण बना रहा हूं और हर बार सबसे अधिक लाभ के साथ सबसे अच्छी विशेषता के आधार पर पेड़ को विभाजित कर रहा हूं। हालांकि, यह हर बार एक ही विशेषता को चिपका रहा है और बस अपने प्रश्न के लिए मान समायोजित कर रहा है। . इसका परिणाम आमतौर पर लगभग 30% की बहुत कम सटीकता में होता है क्योंकि यह केवल पहली विशेषता को ध्यान में रखता है।

सबसे अच्छा विभाजन ढूँढना

 # Used to find the best split for data among all attributes

def split(r):
    max_ig = 0
    max_att = 0
    max_att_val = 0
    i = 0

    curr_gini = gini_index(r)
    n_att = len(att)

    for c in range(n_att):
        if c == 3:
            continue

        c_vals = get_column(r, c)

        while i < len(c_vals):
            # Value of the current attribute that is being tested
            curr_att_val = r[i][c]
            true, false = fork(r, c, curr_att_val)
            ig = gain(true, false, curr_gini)

            if ig > max_ig:
                max_ig = ig
                max_att = c
                max_att_val = r[i][c]
            i += 1

    return max_ig, max_att, max_att_val

सही या गलत के आधार पर डेटा को सत्य में विभाजित करने के लिए तुलना करें

    # Used to compare and test if the current row is greater than or equal to the test value
# in order to split up the data

def compare(r, test_c, test_val):
    if r[test_c].isdigit():
        return r[test_c] == test_val

    elif float(r[test_c]) >= float(test_val):
        return True

    else:
        return False


# Splits the data into two lists for the true/false results of the compare test

def fork(r, c, test_val):
    true = []
    false = []

    for row in r:

        if compare(row, c, test_val):
            true.append(row)
        else:
            false.append(row)

    return true, false

पेड़ के माध्यम से पुनरावृति

def rec_tree(r):
ig, att, curr_att_val = split(r)

if ig == 0:
    return Leaf(r)

true_rows, false_rows = fork(r, att, curr_att_val)

true_branch = rec_tree(true_rows)
false_branch = rec_tree(false_rows)

return Node(att, curr_att_val, true_branch, false_branch)
0
ConnnK 7 पद 2020, 18:17

1 उत्तर

सबसे बढ़िया उत्तर

मेरे पास काम करने वाला समाधान निम्नानुसार विभाजित कार्य को बदलना था। पूरी तरह से ईमानदार होने के लिए मैं यह नहीं देख पा रहा हूं कि क्या गलत है, लेकिन यह स्पष्ट हो सकता है कि कार्य कार्य इस प्रकार है

def split(r):
max_ig = 0
max_att = 0
max_att_val = 0

# calculates gini for the rows provided
curr_gini = gini_index(r)
no_att = len(r[0])

# Goes through the different attributes

for c in range(no_att):

    # Skip the label column (beer style)

    if c == 3:
        continue
    column_vals = get_column(r, c)

    i = 0
    while i < len(column_vals):
        # value we want to check
        att_val = r[i][c]

        # Use the attribute value to fork the data to true and false streams
        true, false = fork(r, c, att_val)

        # Calculate the information gain
        ig = gain(true, false, curr_gini)

        # If this gain is the highest found then mark this as the best choice
        if ig > max_ig:
            max_ig = ig
            max_att = c
            max_att_val = r[i][c]
        i += 1

return max_ig, max_att, max_att_val
0
ConnnK 7 पद 2020, 21:13