def partial_fit(self, X, y, classes=None):
# Initial preperation
if classes is None and self.classes is None:
self.label_encoder = LabelEncoder()
self.label_encoder.fit(y)
self.classes = self.label_encoder.classes_
elif self.classes is None:
self.label_encoder = LabelEncoder()
self.label_encoder.fit(classes)
self.classes = classes
if classes[0] is "positive":
self.minority_name = self.label_encoder.transform(classes[0])
self.majority_name = self.label_encoder.transform(classes[1])
elif classes[1] is "positive":
self.minority_name = self.label_encoder.transform(classes[1])
self.majority_name = self.label_encodr.transform(classes[0])
y = self.label_encoder.transform(y)
if self.minority_name is None or self.majority_name is None:
self.minority_name, self.majority_name = minority_majority_name(y)
self.number_of_features = len(X[0])
# Prune minority
to_delete = []
for i, w in enumerate(self.weights_array_min):
if w <= 0:
to_delete.append(i)
self.weights_array_min[i] -= 1
to_delete.reverse()
for i in to_delete:
del self.weights_array_min[i]
del self.classifier_array_min[i]
# Prune majority
to_delete = []
for i, w in enumerate(self.weights_array_maj):
if w <= 0:
to_delete.append(i)
self.weights_array_maj[i] -= 1
to_delete.reverse()
for i in to_delete:
del self.weights_array_maj[i]
del self.classifier_array_maj[i]
# Split data
minority, majority = minority_majority_split(X, y, self.minority_name, self.majority_name)
samples, n_of_clust = self._best_number_of_clusters(minority, 10)
for i in range(n_of_clust):
self.classifier_array_min.append(clone(self.base_classifier).fit(samples[i]))
self.weights_array_min.append(self.number_of_classifiers)
samples, n_of_clust = self._best_number_of_clusters(majority, 10)
for i in range(n_of_clust):
self.classifier_array_maj.append(clone(self.base_classifier).fit(samples[i]))
self.weights_array_maj.append(self.number_of_classifiers)
def partial_fit(self, X, y, classes=None):
warnings.filterwarnings(action='ignore', category=DeprecationWarning)
if classes is None and self.classes is None:
self.label_encoder = LabelEncoder()
self.label_encoder.fit(y)
self.classes = self.label_encoder.classes
elif self.classes is None:
self.label_encoder = LabelEncoder()
self.label_encoder.fit(classes)
self.classes = classes
y = self.label_encoder.transform(y)
if self.minority_name is None or self.majority_name is None:
self.minority_name, self.majority_name = minority_majority_name(y)
self.sub_ensemble_array += [self._new_sub_ensemble(X, y)]
beta_mean = self._calculate_weights(X, y)
self.classifier_weights = []
for b in beta_mean:
self.classifier_weights.append(math.log(1 / b))
self.iterator += 1
def partial_fit(self, X, y, classes=None):
warnings.filterwarnings(action='ignore', category=DeprecationWarning)
if classes is None and self.classes is None:
self.label_encoder = LabelEncoder()
self.label_encoder.fit(y)
self.classes = self.label_encoder.classes
elif self.classes is None:
self.label_encoder = LabelEncoder()
self.label_encoder.fit(classes)
self.classes = classes
if classes[0] is "positive":
self.minority_name = self.label_encoder.transform(classes[0])
self.majority_name = self.label_encoder.transform(classes[1])
elif classes[1] is "positive":
self.minority_name = self.label_encoder.transform(classes[1])
self.majority_name = self.label_encoder.transform(classes[0])
y = self.label_encoder.transform(y)
if self.minority_name is None or self.majority_name is None:
self.minority_name, self.majority_name = minority_majority_name(y)
res_X, res_y = self._resample(X, y)
if res_X is None:
return
new_classifier = self.base_classifier.fit(res_X, res_y)
if len(self.classifier_array) < self.number_of_classifiers:
self.classifier_array.append(new_classifier)
self.classifier_weights.append(1)
else:
auc_array = []
for i in range(len(self.classifier_array)):
y_score = self.classifier_array[i].predict_proba(res_X)
fpr, tpr, thresholds = metrics.roc_curve(res_y, y_score[:, 0])
auc_array += [metrics.auc(fpr, tpr)]
j = np.argmin(auc_array)
y_score = new_classifier.predict_proba(res_X)
fpr, tpr, thresholds = metrics.roc_curve(res_y, y_score[:, 0])
new_auc = metrics.auc(fpr, tpr)
if new_auc > auc_array[j]:
self.classifier_array[j] = new_classifier
auc_array[j] = new_auc
# auc_norm = auc_array / np.linalg.norm(auc_array)
for i in range(len(self.classifier_array)):
self.classifier_weights[i] = auc_array[i]
def partial_fit(self, X, y, classes=None):
if classes is None and self.classes is None:
self.label_encoder = LabelEncoder()
self.label_encoder.fit(y)
self.classes = self.label_encoder.classes
elif self.classes is None:
self.label_encoder = LabelEncoder()
self.label_encoder.fit(classes)
self.classes = classes
if classes[0] is "positive":
self.minority_name = self.label_encoder.transform(classes[0])
self.majority_name = self.label_encoder.transform(classes[1])
elif classes[1] is "positive":
self.minority_name = self.label_encoder.transform(classes[1])
self.majority_name = self.label_encoder.transform(classes[0])
y = self.label_encoder.transform(y)
if self.minority_name is None or self.majority_name is None:
self.minority_name, self.majority_name = minority_majority_name(y)
res_X, res_y = self._resample(X, y)
new_classifier = clone(self.base_classifier).fit(res_X, res_y)
self.classifier_array.append(new_classifier)
if len(self.classifier_array) >= self.number_of_classifiers:
worst = np.argmin(self.classifier_weights)
del self.classifier_array[worst]
del self.classifier_weights[worst]
# s1 = 1/float(len(X))
weights = []
for clf in self.classifier_array:
proba = clf.predict_proba(X)
s2 = 0
for i, x in enumerate(X):
try:
probas = proba[i][y[i]]
except IndexError:
probas = 0
s2 += math.pow((1 - probas), 2)
if s2 == 0:
s2 = 0.00001
s2 = s2 / len(X)
s3 = math.log(1 / s2)
weights.append(s3)
self.classifier_weights = weights
def partial_fit(self, X, y, classes=None):
warnings.filterwarnings(action='ignore', category=DeprecationWarning)
if classes is None and self.classes is None:
self.label_encoder = LabelEncoder()
self.label_encoder.fit(y)
self.classes_ = self.label_encoder.classes_
elif self.classes is None:
self.label_encoder = LabelEncoder()
self.label_encoder.fit(classes)
self.classes = classes
y = self.label_encoder.transform(y)
if self.minority_name is None or self.majority_name is None:
self.minority_name, self.majority_name = minority_majority_name(y)
res_X, res_y = self._resample(X, y)
new_classifier = clone(self.base_classifier).fit(res_X, res_y)
self.classifier_array.append(new_classifier)
# if len(self.classifier_array) >= self.number_of_classifiers:
# worst = np.argmin(self.classifier_weights)
# del self.classifier_array[worst]
# del self.classifier_weights[worst]
# s1 = 1/float(len(X))
weights = []
for clf in self.classifier_array:
proba = clf.predict_proba(X)
s2 = 0
for i, x in enumerate(X):
probas = proba[i][y[i]]
s2 += math.pow((1 - probas), 2)
if s2 == 0:
s2 = 0.00001
s2 = s2 / len(X)
s3 = math.log(1 / s2)
weights.append(s3)
self.classifier_weights = weights
def partial_fit(self, X, y, classes=None):
if classes is None and self.classes is None:
self.label_encoder = LabelEncoder()
self.label_encoder.fit(y)
self.classes = self.label_encoder.classes
elif self.classes is None:
self.label_encoder = LabelEncoder()
self.label_encoder.fit(classes)
self.classes = classes
if classes[0] is "positive":
self.minority_name = self.label_encoder.transform(classes[0])
self.majority_name = self.label_encoder.transform(classes[1])
elif classes[1] is "positive":
self.minority_name = self.label_encoder.transform(classes[1])
self.majority_name = self.label_encoder.transform(classes[0])
y = self.label_encoder.transform(y)
if self.minority_name is None or self.majority_name is None:
self.minority_name, self.majority_name = minority_majority_name(y)
new_minority = self._resample(X, y)
minority, majority = minority_majority_split(X, y, self.minority_name,
self.majority_name)
if not majority.any():
return
majority_split = np.array_split(majority, self.number_of_classifiers)
self.classifier_array = []
for m_s in majority_split:
res_X = np.concatenate((m_s, new_minority), axis=0)
res_y = len(m_s) * [self.majority_name
] + len(new_minority) * [self.minority_name]
new_classifier = clone(self.base_classifier).fit(res_X, res_y)
self.classifier_array.append(new_classifier)
self.time_stamp += 1
def partial_fit(self, X, y, classes=None):
warnings.filterwarnings(action='ignore', category=DeprecationWarning)
if classes is None and self.classes is None:
self.label_encoder = LabelEncoder()
self.label_encoder.fit(y)
self.classes = self.label_encoder.classes
elif self.classes is None:
self.label_encoder = LabelEncoder()
self.label_encoder.fit(classes)
self.classes = classes
if classes[0] is "positive":
self.minority_name = self.label_encoder.transform(classes[0])
self.majority_name = self.label_encoder.transform(classes[1])
elif classes[1] is "positive":
self.minority_name = self.label_encoder.transform(classes[1])
self.majority_name = self.label_encoder.transform(classes[0])
y = self.label_encoder.transform(y)
if self.minority_name is None or self.majority_name is None:
self.minority_name, self.majority_name = minority_majority_name(y)
new_minority = self._resample(X, y)
minority, majority = minority_majority_split(X, y, self.minority_name, self.majority_name)
if not majority.any():
print("majoirty empty")
return
majority_split = np.array_split(majority, self.number_of_classifiers)
self.classifier_array = []
for m_s in majority_split:
res_X = np.concatenate((m_s, new_minority), axis=0)
res_y = len(m_s)*[self.majority_name] + len(new_minority)*[self.minority_name]
new_classifier = self.base_classifier.fit(res_X, res_y)
self.classifier_array.append(new_classifier)
def partial_fit(self, X, y, classes=None):
warnings.filterwarnings(action='ignore', category=DeprecationWarning)
if classes is None and self.classes is None:
self.label_encoder = LabelEncoder()
self.label_encoder.fit(y)
self.classes = self.label_encoder.classes
elif self.classes is None:
self.label_encoder = LabelEncoder()
self.label_encoder.fit(classes)
self.classes = classes
y = self.label_encoder.transform(y)
if self.minority_name is None or self.majority_name is None:
self.minority_name, self.majority_name = minority_majority_name(y)
self.number_of_instances = len(y)
if self.classifier_array:
y_pred = self.predict(X)
y_pred = self.label_encoder.transform(y_pred)
E = (1 - metrics.accuracy_score(y, y_pred))
eq = np.equal(y, y_pred)
w = np.zeros(eq.shape)
w[eq == True] = E / float(self.number_of_instances)
w[eq == False] = 1 / float(self.number_of_instances)
w_sum = np.sum(w)
D = w / w_sum
res_X, res_y = self._resample(X, y)
new_classifier = clone(self.base_classifier).fit(res_X, res_y)
self.classifier_array.append(new_classifier)
beta = []
epsilon_sum_array = []
for j in range(len(self.classifier_array)):
y_pred = self.classifier_array[j].predict(X)
eq_2 = np.not_equal(y, y_pred).astype(int)
epsilon_sum = np.sum(eq_2 * D)
epsilon_sum_array.append(epsilon_sum)
if epsilon_sum > 0.5:
if j is len(self.classifier_array) - 1:
self.classifier_array[j] = clone(
self.base_classifier).fit(res_X, res_y)
else:
epsilon_sum = 0.5
epsilon_sum_array = np.array(epsilon_sum_array)
beta = epsilon_sum_array / (1 - epsilon_sum_array)
sigma = []
a = self.param_a
b = self.param_b
t = len(self.classifier_array)
k = np.array(range(t))
sigma = 1 / (1 + np.exp(-a * (t - k - b)))
sigma_mean = []
for k in range(t):
sigma_sum = np.sum(sigma[0:t - k])
sigma_mean.append(sigma[k] / sigma_sum)
beta_mean = []
for k in range(t):
beta_sum = np.sum(sigma_mean[0:t - k] * beta[0:t - k])
beta_mean.append(beta_sum)
self.classifier_weights = []
for b in beta_mean:
self.classifier_weights.append(math.log(1 / b))
if t >= self.number_of_classifiers:
ind = np.argmax(beta_mean)
del self.classifier_array[ind]
del self.classifier_weights[ind]
else:
res_X, res_y = self._resample(X, y)
new_classifier = clone(self.base_classifier).fit(res_X, res_y)
self.classifier_array.append(new_classifier)
self.classifier_weights = [1]
def partial_fit(self, X, y, classes=None):
# ________________________________________
# Initial preperation
if classes is None and self.classes is None:
self.label_encoder = LabelEncoder()
self.label_encoder.fit(y)
self.classes = self.label_encoder.classes
elif self.classes is None:
self.label_encoder = LabelEncoder()
self.label_encoder.fit(classes)
self.classes = classes
if classes[0] is "positive":
self.minority_name = self.label_encoder.transform(classes[0])
self.majority_name = self.label_encoder.transform(classes[1])
elif classes[1] is "positive":
self.minority_name = self.label_encoder.transform(classes[1])
self.majority_name = self.label_encoder.transform(classes[0])
y = self.label_encoder.transform(y)
if self.minority_name is None or self.majority_name is None:
self.minority_name, self.majority_name = minority_majority_name(y)
self.number_of_features = len(X[0])
# ________________________________________
# Get stored data
new_X, new_y = [], []
for tmp_X, tmp_y in zip(self.stored_X, self.stored_y):
new_X.extend(tmp_X)
new_y.extend(tmp_y)
new_X.extend(X)
new_y.extend(y)
new_X = np.array(new_X)
new_y = np.array(new_y)
# ________________________________________
# Undersample and store new data
und_X, und_y = self.undersampling.fit_resample(X, y)
self.stored_X.append(und_X)
self.stored_y.append(und_y)
if len(self.stored_X) > self.number_of_chunks:
del self.stored_X[0]
del self.stored_y[0]
# ________________________________________
# Oversample when below ratio
minority, majority = minority_majority_split(new_X, new_y, self.minority_name, self.majority_name)
ratio = len(minority)/len(majority)
if ratio < self.balance_ratio:
new_X, new_y = self.oversampling.fit_resample(new_X, new_y)
# ________________________________________
# Train classifier
self.clf = self.base_classifier.fit(new_X, new_y)
def partial_fit(self, X, y, classes=None):
warnings.filterwarnings(action='ignore', category=DeprecationWarning)
if classes is None and self.classes is None:
self.label_encoder = LabelEncoder()
self.label_encoder.fit(y)
self.classes = self.label_encoder.classes
elif self.classes is None:
self.label_encoder = LabelEncoder()
self.label_encoder.fit(classes)
self.classes = classes
y = self.label_encoder.transform(y)
if self.minority_name is None or self.majority_name is None:
self.minority_name, self.majority_name = minority_majority_name(y)
if self.classifier_array:
y_pred = self.predict(X)
E = metrics.accuracy_score(y, y_pred)
w = []
for i in range(len(y)):
if y[i] is y_pred[i]:
w.append(E/float(len(y)))
else:
w.append(1/float(len(y)))
D = []
w_sum = np.sum(w)
for i in range(len(y)):
D.append(w[i]/w_sum)
res_X, res_y = self._resample(X, y)
new_classifier = self.base_classifier.fit(res_X, res_y)
self.classifier_array.append(new_classifier)
epsilon = []
beta = []
for j in range(len(self.classifier_array)):
y_pred = self.classifier_array[j].predict(X)
for i in range(len(y)):
if y[i] is not y_pred[i]:
epsilon.append(D[i])
epsilon_sum = np.sum(epsilon)
if epsilon_sum > 0.5:
if j is len(self.classifier_array) - 1:
self.classifier_array[j] = self.base_classifier.fit(res_X, res_y)
else:
epsilon_sum = 0.5
beta.append(epsilon_sum / float(1 - epsilon_sum))
sigma = []
a = self.param_a
b = self.param_b
t = self.iterator
for k in range(t):
sigma.append(1/(1 + math.exp(-a*(t-k-b))))
sigma_mean = []
for k in range(t):
sigma_sum = 0
for j in range(t-k):
sigma_sum += sigma[j]
sigma_mean.append(sigma[k]/sigma_sum)
beta_mean = []
for k in range(t):
beta_sum = 0
for j in range(t-k):
beta_sum += sigma_mean[j]*beta[j]
beta_mean.append(beta_sum)
self.classifier_weights = []
for b in beta_mean:
self.classifier_weights.append(math.log(1/b))
self.iterator += 1
else:
res_X, res_y = self._resample(X, y)
new_classifier = self.base_classifier.fit(res_X, res_y)
self.classifier_array.append(new_classifier)
self.classifier_weights = [1]
self.iterator += 1
def partial_fit(self, X, y, classes=None):
# ________________________________________
# Initial preperation
if classes is None and self.classes is None:
self.label_encoder = LabelEncoder()
self.label_encoder.fit(y)
self.classes = self.label_encoder.classes
elif self.classes is None:
self.label_encoder = LabelEncoder()
self.label_encoder.fit(classes)
self.classes = classes
if classes[0] is "positive":
self.minority_name = self.label_encoder.transform(classes[0])
self.majority_name = self.label_encoder.transform(classes[1])
elif classes[1] is "positive":
self.minority_name = self.label_encoder.transform(classes[1])
self.majority_name = self.label_encoder.transform(classes[0])
y = self.label_encoder.transform(y)
if self.minority_name is None or self.majority_name is None:
self.minority_name, self.majority_name = minority_majority_name(y)
self.number_of_features = len(X[0])
# ________________________________________
# Drift detector
if (self.drift_detector is not None):
dd_pred = self.drift_detector.predict(X)
score = geometric_mean_score(dd_pred, y)
if score / np.mean(self.metrics_array) < 0.7:
self.drift_detector = None
self.metrics_array = []
self.classifier_array = []
self.stored_X = []
self.stored_y = []
else:
self.metrics_array.append(score)
# ________________________________________
# Get stored data
new_X, new_y = [], []
for tmp_X, tmp_y in zip(self.stored_X, self.stored_y):
new_X.extend(tmp_X)
new_y.extend(tmp_y)
new_X.extend(X)
new_y.extend(y)
new_X = np.array(new_X)
new_y = np.array(new_y)
# ________________________________________
# Undersample and store new data
und_X, und_y = self.undersampling.fit_resample(X, y)
self.stored_X.append(und_X)
self.stored_y.append(und_y)
# ________________________________________
# Oversample when below ratio
minority, majority = minority_majority_split(new_X, new_y,
self.minority_name,
self.majority_name)
ratio = len(minority) / len(majority)
if ratio < self.balance_ratio:
new_X, new_y = self.oversampling.fit_resample(new_X, new_y)
# ________________________________________
# Train new classifier
self.classifier_array.append(
clone(self.base_classifier).fit(new_X, new_y))
if len(self.classifier_array) >= self.number_of_classifiers:
del self.classifier_array[0]
del self.stored_X[0]
del self.stored_y[0]
if self.drift_detector is None:
self.drift_detector = MLPClassifier((10))
self.drift_detector.partial_fit(new_X, new_y, np.unique(new_y))
self.iteration += 1