def test_check_random_state(): rand = None rand = check_random_state(rand) assert isinstance(rand, np.random.mtrand.RandomState) rand = check_random_state(rand) assert isinstance(rand, np.random.mtrand.RandomState) rand = check_random_state(int(1)) assert isinstance(rand, np.random.mtrand.RandomState) with pytest.raises(ValueError): check_random_state(2.0)
def generate_centroids(self): """ generate_centroids The centroids are generated just as it's done in the parent class, the difference is the extra step taken to setup the drift, if there's any. To __configure the drift, random offset speeds are chosen for self.num_drift_centroids centroids. Finally, the speed are normalized. """ super().generate_centroids() model_random_state = check_random_state( self._original_model_random_state) num_drift_centroids = self.num_drift_centroids self.centroid_speed = [] if num_drift_centroids > self.n_centroids: num_drift_centroids = self.n_centroids for i in range(num_drift_centroids): rand_speed = [] norm_speed = 0.0 for j in range(self.n_num_features): rand_speed.append(model_random_state.rand()) norm_speed += rand_speed[j] * rand_speed[j] norm_speed = np.sqrt(norm_speed) for j in range(self.n_num_features): rand_speed[j] /= norm_speed self.centroid_speed.append(rand_speed)
def __init__(self, nb_ensemble=10, max_features='auto', disable_weighted_vote=False, lambda_value=6, performance_metric='acc', drift_detection_method: BaseDriftDetector = ADWIN(0.001), warning_detection_method: BaseDriftDetector = ADWIN(0.01), max_byte_size=33554432, memory_estimate_period=2000000, grace_period=50, split_criterion='info_gain', split_confidence=0.01, tie_threshold=0.05, binary_split=False, stop_mem_management=False, remove_poor_atts=False, no_preprune=False, leaf_prediction='nba', nb_threshold=0, nominal_attributes=None, random_state=None): """AdaptiveRandomForest class constructor.""" super().__init__() self.nb_ensemble = nb_ensemble self.max_features = max_features self.disable_weighted_vote = disable_weighted_vote self.lambda_value = lambda_value if isinstance(drift_detection_method, BaseDriftDetector): self.drift_detection_method = drift_detection_method else: self.drift_detection_method = None if isinstance(warning_detection_method, BaseDriftDetector): self.warning_detection_method = warning_detection_method else: self.warning_detection_method = None self.instances_seen = 0 self._train_weight_seen_by_model = 0.0 self.ensemble = None self.random_state = check_random_state(random_state) if performance_metric in ['acc', 'kappa']: self.performance_metric = performance_metric else: raise ValueError( 'Invalid performance metric: {}'.format(performance_metric)) # ARH Hoeffding Tree configuration self.max_byte_size = max_byte_size self.memory_estimate_period = memory_estimate_period self.grace_period = grace_period self.split_criterion = split_criterion self.split_confidence = split_confidence self.tie_threshold = tie_threshold self.binary_split = binary_split self.stop_mem_management = stop_mem_management self.remove_poor_atts = remove_poor_atts self.no_preprune = no_preprune self.leaf_prediction = leaf_prediction self.nb_threshold = nb_threshold self.nominal_attributes = nominal_attributes
def prepare_for_use(self): """ Should be called before generating the samples. """ self.random_state = check_random_state(self._original_random_state) self.sample_idx = 0
def generate_random_tree(self): """ generate_random_tree Generates the random tree, starting from the root node and following the constraints passed as parameters to the initializer. The tree is recursively generated, node by node, until it reaches the maximum tree depth. """ # Starting random generators and parameter arrays tree_random_state = check_random_state( self._original_tree_random_state) nominal_att_candidates = array('i') min_numeric_value = array('d') max_numeric_value = array('d') for i in range(self.n_num_features): min_numeric_value.append(0.0) max_numeric_value.append(1.0) for i in range(self.n_num_features + self.n_cat_features): nominal_att_candidates.append(i) self.tree_root = self.generate_random_tree_node( 0, nominal_att_candidates, min_numeric_value, max_numeric_value, tree_random_state)
def __init__(self, split_test, class_observations): SplitNode.__init__(self, split_test, class_observations) self._estimation_error_weight = ADWIN() self._alternate_tree = None self.error_change = False self._random_seed = 1 self._classifier_random = check_random_state(self._random_seed)
def prepare_for_use(self): """ Sould be called before generating the samples. """ self.random_state = check_random_state(self._original_random_state) self.next_class_should_be_zero = False self.sample_idx = 0
def prepare_for_use(self): self.random_state = check_random_state(self._original_random_state) self.sample_idx = 0 self._input_stream.prepare_for_use() self._drift_stream.prepare_for_use() if self.alpha_option != 0.0: self.width_option = int(1 / np.tan(self.alpha_option * np.pi / 180))
def __configure(self): self.random_state = check_random_state(self._original_random_state) self.n_cat_features = self._TOTAL_ATTRIBUTES_INCLUDING_NOISE if self.has_noise else self._NUM_BASE_ATTRIBUTES self.n_features = self.n_cat_features self.feature_names = [ "att_num_" + str(i) for i in range(self.n_cat_features) ] self.target_values = [i for i in range(self.n_targets)]
def prepare_for_use(self): """ Should be called before generating the samples. """ self.random_state = check_random_state(self._original_random_state) self._next_class_should_be_zero = False self.sample_idx = 0 for i in range(self.n_features): self._weights[i] = self.random_state.rand() self._sigma[i] = 1 if (i < self.n_drift_features) else 0
def _partial_fit(self, X, y, weight): self.instances_seen += 1 if self.ensemble is None: self.init_ensemble(X) for i in range(self.nb_ensemble): y_predicted = self.ensemble[i].predict(np.asarray([X])) self.ensemble[i].evaluator.add_result(y_predicted, y, weight) rnd = check_random_state(self.random_state) k = rnd.poisson(self.lambda_value) if k > 0: self.ensemble[i].partial_fit(np.asarray([X]), np.asarray([y]), np.asarray([k]), self.instances_seen)
def __init__(self, n_samples=40000, n_features=100, n_informative=10, n_targets=1, random_state=None): super().__init__() self.X = None self.y = None self.n_samples = n_samples self.n_features = n_features self.n_targets = n_targets self.n_informative = n_informative self.n_num_features = n_features self.n_features = n_features self.random_state = check_random_state(random_state) self.name = "Regression Generator" self.__configure()
def __init__(self, n_samples=40000, n_features=20, n_targets=5, n_labels=2, random_state=None): super().__init__() self.X = None self.y = None self.n_samples = n_samples self.n_features = n_features self.n_targets = n_targets self.n_labels = n_labels self.n_classes = 2 self.n_num_features = n_features self.random_state = check_random_state(random_state) self.name = "Multilabel Generator" self.__configure()
def __init__(self, n_samples=40000, n_features=20, n_targets=5, n_labels=2, random_state=None): super().__init__() self.X = None self.y = None self.num_samples = 0 self.num_features = 0 self.num_target_tasks = 0 self.num_labels = 0 self.num_numerical_attributes = 0 self.num_nominal_attributes = 0 self.num_values_per_nominal_att = 0 self.instance_index = 0 self.current_instance_y = None self.current_instance_x = None self.random_state = check_random_state(random_state) self.__configure(n_samples, n_features, n_targets, n_labels)
def generate_centroids(self): """ generate_centroids Sequentially creates all the centroids, choosing at random a center, a label, a standard deviation and a weight. """ model_random_state = check_random_state( self._original_model_random_state) self.centroids = [] self.centroid_weights = [] for i in range(self.n_centroids): self.centroids.append(Centroid()) rand_centre = [] for j in range(self.n_num_features): rand_centre.append(model_random_state.rand()) self.centroids[i].centre = rand_centre self.centroids[i].class_label = model_random_state.randint( self.n_classes) self.centroids[i].std_dev = model_random_state.rand() self.centroid_weights.append(model_random_state.rand())
def prepare_for_use(self): self.random_state = check_random_state(self._original_random_state) self.next_class_should_be_zero = False self.sample_idx = 0
def prepare_for_use(self): self.sample_random_state = check_random_state( self._original_sample_random_state) self.sample_idx = 0 self.generate_random_tree()
def prepare_for_use(self): self.random_state = check_random_state(self._original_random_state) self.sample_idx = 0
def prepare_for_use(self): self.generate_centroids() self.sample_random_state = check_random_state( self._original_sample_random_state)
def _sample_features(self, n_features): rnd = check_random_state(self.random_state) return rnd.choice(n_features, size=self.max_features, replace=False)
def __init__(self, initial_class_observations): LearningNodeNBAdaptive.__init__(self, initial_class_observations) self.estimationErrorWeight = ADWIN() self.ErrorChange = False self._randomSeed = 1 self._classifier_random = check_random_state(self._randomSeed)