决策树算法（C4.5）

X = [['sunny',    'hot',   'h_85',   'weak'],
     ['sunny',    'hot',   'h_90',   'strong'], 
     ['overcast', 'hot',   'h_78',   'weak'], 
     ['rain',     'mild',  'h_96',   'weak'], 
     ['rain',     'cool',  'h_80', 'weak'], 
     ['rain',     'cool',  'h_70', 'strong'], 
     ['overcast', 'cool',  'h_65', 'strong'], 
     ['sunny',    'mild',  'h_95',   'weak'], 
     ['sunny',    'cool',  'h_70', 'weak'], 
     ['rain',     'mild',  'h_80', 'weak'], 
     ['sunny',    'mild',  'h_70', 'strong'], 
     ['overcast', 'mild',  'h_90',   'strong'], 
     ['overcast', 'hot',   'h_75', 'weak'], 
     ['rain',     'mild',  'h_80',   'strong'], 
]

estimator = Id3Estimator(gain_ratio=1)

for i in range(self.n_features):
            if check_input and check_numerical_array(X_[:, i]):
                self.is_numerical[i] = True
                X_tmp[:, i] = X_[:, i]
            else:
                X_tmp[:, i] = self.X_encoders[i].fit_transform(X_[:, i])

def check_numerical_array(array):
    """ Check if all values in a 1d array are numerical. Raises error if array
        is more than 1d.

    Parameters
    ----------
    array : nparray
        containing the class names

    Returns
    -------
    result : bool
        True if all values in array are numerical, otherwise false
    """
    try:
        if array.ndim > 1:
            raise ArithmeticError("Found array with dim {}. Expected = 1."
                                  .format(array.ndim))
        array.astype(np.float64)
        return True
    except ValueError:
        return False

def _info_numerical(self, x, y):
        """ Info for numerical feature feature_values
        sort values then find the best split value

        Parameters
        ----------
        x : np.array of shape [n remaining examples]
            containing feature values
        y : np.array of shape [n remaining examples]
            containing relevent class

        Returns
        -------
        : float
            information for remaining examples given feature
        : float
            pivot used set1 < pivot <= set2
        """
        n = x.size
        sorted_idx = np.argsort(x, kind='quicksort')
        sorted_y = np.take(y, sorted_idx, axis=0)
        sorted_x = np.take(x, sorted_idx, axis=0)
        min_info = float('inf')
        min_info_pivot = 0
        min_attribute_counts = np.empty(2)
        for i in range(1, n):
            if sorted_x[i - 1] != sorted_x[i]:
                tmp_info = i * self._entropy(sorted_y[0: i]) + \
                           (n - i) * self._entropy(sorted_y[i:])
                if tmp_info < min_info:
                    min_attribute_counts[SplitRecord.LESS] = i
                    min_attribute_counts[SplitRecord.GREATER] = n - i
                    min_info = tmp_info
                    min_info_pivot = (sorted_x[i - 1] + sorted_x[i]) / 2.0
        return CalcRecord(CalcRecord.NUM,
                          min_info * np.true_divide(1, n),
                          pivot=min_info_pivot,
                          attribute_counts=min_attribute_counts)

def _is_better(self, calc_record1, calc_record2):
        """Compares CalcRecords using gain ratio if present otherwise
           using the  information.

        Parameters
        ----------
        calc_record1 : CalcRecord
        calc_record2 : CalcRecord

        Returns
        -------
        : bool
            if calc_record1 < calc_record2
        """
        if calc_record1 is None:
            return True
        if calc_record2 is None:
            return False
        if self.gain_ratio:
            if calc_record1.gain_ratio is None:
                calc_record1.gain_ratio = self._gain_ratio(calc_record1)
            if calc_record2.gain_ratio is None:
                calc_record2.gain_ratio = self._gain_ratio(calc_record2)
            if self._is_close(calc_record1.gain_ratio,
                              calc_record2.gain_ratio):
                return calc_record1.info > calc_record2.info
            else:
                return calc_record1.gain_ratio < calc_record2.gain_ratio
        else:
            return calc_record1.info > calc_record2.info