def all_KNN(X, Y):
from imblearn.under_sampling import AllKNN
allknn = AllKNN()
allknn.fit_resample(X, Y)
indexes = allknn.sample_indices_
nobj = len(Y)
mask = np.zeros(nobj, dtype=int)
for i in range(nobj):
if i in indexes:
mask[i] = 1
return True, mask
def all_KNN(X, Y):
from imblearn.under_sampling import AllKNN
allknn = AllKNN()
allknn.fit_resample(X, Y)
indexes = allknn.sample_indices_
mask = []
for i in range(len(X)):
if i in indexes:
mask.append(1)
else:
mask.append(0)
return True, np.asarray(mask)
def test_allknn_fit_resample_with_nn_object():
nn = NearestNeighbors(n_neighbors=4)
allknn = AllKNN(n_neighbors=nn, kind_sel='mode')
X_resampled, y_resampled = allknn.fit_resample(X, Y)
X_gt = np.array([[-0.53171468, -0.53735182], [-0.88864036, -0.33782387], [
-0.46226554, -0.50481004
], [-0.34474418, 0.21969797], [-0.12840393, 0.66446571], [
1.02956816, 0.36061601
], [1.12202806, 0.33811558], [-0.35946678, 0.72510189], [
-1.10146139, 0.91782682
], [0.73489726, 0.43915195], [-0.28479268, 0.70459548], [
0.50307437, 0.498805
], [0.84929742, 0.41042894], [0.62649535, 0.46600596], [
0.98382284, 0.37184502
], [0.69804044, 0.44810796], [1.32319756, -0.13181616], [
0.04296502, -0.37981873
], [0.28294738, -1.00125525], [0.34218094, -0.58781961], [
0.2096964, -0.61814058
], [1.59068979, -0.96622933], [0.73418199, -0.02222847], [
0.79270821, -0.41386668
], [1.16606871, -0.25641059], [1.0304995, -0.16955962], [
0.48921682, -1.38504507
], [-0.03918551, -0.68540745], [0.24991051, -1.00864997],
[0.80541964, -0.34465185], [0.1732627, -1.61323172]])
y_gt = np.array([
0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2
])
assert_array_equal(X_resampled, X_gt)
assert_array_equal(y_resampled, y_gt)
def test_allknn_fit_resample_with_indices():
allknn = AllKNN(return_indices=True)
X_resampled, y_resampled, idx_under = allknn.fit_resample(X, Y)
X_gt = np.array([[-0.53171468, -0.53735182], [-0.88864036, -0.33782387], [
-0.46226554, -0.50481004
], [-0.34474418, 0.21969797], [1.02956816, 0.36061601], [
1.12202806, 0.33811558
], [-1.10146139, 0.91782682], [0.73489726, 0.43915195], [
0.50307437, 0.498805
], [0.84929742, 0.41042894], [0.62649535, 0.46600596], [
0.98382284, 0.37184502
], [0.69804044, 0.44810796], [0.04296502, -0.37981873], [
0.28294738, -1.00125525
], [0.34218094, -0.58781961], [0.2096964, -0.61814058], [
1.59068979, -0.96622933
], [0.73418199, -0.02222847], [0.79270821, -0.41386668], [
1.16606871, -0.25641059
], [1.0304995, -0.16955962], [0.48921682, -1.38504507],
[-0.03918551, -0.68540745], [0.24991051, -1.00864997],
[0.80541964, -0.34465185], [0.1732627, -1.61323172]])
y_gt = np.array([
0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2
])
idx_gt = np.array([
6, 13, 32, 39, 4, 5, 14, 16, 22, 23, 24, 30, 37, 2, 11, 12, 17, 20, 21,
25, 26, 28, 31, 33, 34, 35, 36
])
assert_allclose(X_resampled, X_gt, rtol=R_TOL)
assert_allclose(y_resampled, y_gt, rtol=R_TOL)
assert_allclose(idx_under, idx_gt, rtol=R_TOL)
def test_allknn_fit_resample_with_nn_object():
nn = NearestNeighbors(n_neighbors=4)
allknn = AllKNN(n_neighbors=nn, kind_sel='mode')
X_resampled, y_resampled = allknn.fit_resample(X, Y)
X_gt = np.array([[-0.53171468, -0.53735182], [-0.88864036, -0.33782387],
[-0.46226554, -0.50481004], [-0.34474418, 0.21969797],
[-0.12840393, 0.66446571], [1.02956816, 0.36061601],
[1.12202806, 0.33811558], [-0.35946678, 0.72510189],
[-1.10146139, 0.91782682], [0.73489726, 0.43915195],
[-0.28479268, 0.70459548], [0.50307437, 0.498805],
[0.84929742, 0.41042894], [0.62649535, 0.46600596],
[0.98382284, 0.37184502], [0.69804044, 0.44810796],
[1.32319756, -0.13181616], [0.04296502, -0.37981873],
[0.28294738, -1.00125525], [0.34218094, -0.58781961],
[0.2096964, -0.61814058], [1.59068979, -0.96622933],
[0.73418199, -0.02222847], [0.79270821, -0.41386668],
[1.16606871, -0.25641059], [1.0304995, -0.16955962],
[0.48921682, -1.38504507], [-0.03918551, -0.68540745],
[0.24991051, -1.00864997], [0.80541964, -0.34465185],
[0.1732627, -1.61323172]])
y_gt = np.array([
0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2
])
assert_array_equal(X_resampled, X_gt)
assert_array_equal(y_resampled, y_gt)
def test_allknn_fit_resample_with_indices():
allknn = AllKNN(return_indices=True)
X_resampled, y_resampled, idx_under = allknn.fit_resample(X, Y)
X_gt = np.array([[-0.53171468, -0.53735182], [-0.88864036, -0.33782387],
[-0.46226554, -0.50481004], [-0.34474418, 0.21969797],
[1.02956816, 0.36061601], [1.12202806, 0.33811558],
[-1.10146139, 0.91782682], [0.73489726, 0.43915195],
[0.50307437, 0.498805], [0.84929742, 0.41042894],
[0.62649535, 0.46600596], [0.98382284, 0.37184502],
[0.69804044, 0.44810796], [0.04296502, -0.37981873],
[0.28294738, -1.00125525], [0.34218094, -0.58781961],
[0.2096964, -0.61814058], [1.59068979, -0.96622933],
[0.73418199, -0.02222847], [0.79270821, -0.41386668],
[1.16606871, -0.25641059], [1.0304995, -0.16955962],
[0.48921682, -1.38504507], [-0.03918551, -0.68540745],
[0.24991051, -1.00864997], [0.80541964, -0.34465185],
[0.1732627, -1.61323172]])
y_gt = np.array([
0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2
])
idx_gt = np.array([
6, 13, 32, 39, 4, 5, 14, 16, 22, 23, 24, 30, 37, 2, 11, 12, 17, 20, 21,
25, 26, 28, 31, 33, 34, 35, 36
])
assert_allclose(X_resampled, X_gt, rtol=R_TOL)
assert_allclose(y_resampled, y_gt, rtol=R_TOL)
assert_allclose(idx_under, idx_gt, rtol=R_TOL)
def test_all_knn_allow_minority():
X, y = make_classification(n_samples=10000,
n_features=2,
n_informative=2,
n_redundant=0,
n_repeated=0,
n_classes=3,
n_clusters_per_class=1,
weights=[0.2, 0.3, 0.5],
class_sep=0.4,
random_state=0)
allknn = AllKNN(allow_minority=True)
X_res_1, y_res_1 = allknn.fit_resample(X, y)
allknn = AllKNN()
X_res_2, y_res_2 = allknn.fit_resample(X, y)
assert len(y_res_1) < len(y_res_2)
def test_all_knn_allow_minority():
X, y = make_classification(
n_samples=10000,
n_features=2,
n_informative=2,
n_redundant=0,
n_repeated=0,
n_classes=3,
n_clusters_per_class=1,
weights=[0.2, 0.3, 0.5],
class_sep=0.4,
random_state=0)
allknn = AllKNN(allow_minority=True)
X_res_1, y_res_1 = allknn.fit_resample(X, y)
allknn = AllKNN()
X_res_2, y_res_2 = allknn.fit_resample(X, y)
assert len(y_res_1) < len(y_res_2)
def resample(self):
"""
Resampling data usinf AllKNN and SMOTE
"""
print("Sampling data...")
# Under Sampling
allknn = AllKNN(sampling_strategy={28: 565})
self.X, self.y = allknn.fit_resample(self.X, self.y)
#Over Sampling
smote = SMOTE(ratio="all")
self.X, self.y = smote.fit_resample(self.X, self.y)
def aiiknn(X,
y,
visualize=False,
pca2d=True,
pca3d=True,
tsne=True,
pie_evr=True):
allknn = AllKNN()
X_res, y_res = allknn.fit_resample(X, y)
if visualize == True:
hist_over_and_undersampling(y_res)
pca_general(X_res, y_res, d2=pca2d, d3=pca3d, pie_evr=pie_evr)
return X_res, y_res
def fit(self, X, y):
# Preparação dos argumentos para os métodos da biblioteca ``scikit-learn``
#Xlinha = X[self.columns]
#ylinha = y
allknn = AllKNN()
#allknn = AllKNN()
X_resampled, y_resampled = allknn.fit_resample(X, y)
X_train, X_test, y_train, y_test = train_test_split(X_resampled,
y_resampled,
test_size=0.2,
random_state=1)
model = XGBClassifier()
return model
def Allknn_us(X_train,
Y_train,
seed,
sampling_strategy,
n_neighbors=3,
kind_sel='all'):
knn = AllKNN(random_state=seed,
n_jobs=-1,
n_neighbors=n_neighbors,
kind_sel=kind_sel,
sampling_strategy=sampling_strategy)
print('Before Allknn undersampling : ', sorted(Counter(Y_train).items()))
X_train_resampled, Y_train_resampled = knn.fit_resample(X_train, Y_train)
print('After Allknn undersampling : ',
sorted(Counter(Y_train_resampled).items()))
X_train_resampled, Y_train_resampled = shuffle_dataset(
X_train_resampled, Y_train_resampled, seed)
return X_train_resampled, Y_train_resampled
def test_deprecation_random_state():
allknn = AllKNN(random_state=0)
with warns(DeprecationWarning,
match="'random_state' is deprecated from 0.4"):
allknn.fit_resample(X, Y)
def test_alknn_not_good_object():
nn = 'rnd'
allknn = AllKNN(n_neighbors=nn, kind_sel='mode')
with raises(ValueError):
allknn.fit_resample(X, Y)
X_res_vis = pca.transform(X_resampled)
idx_samples_removed = np.setdiff1d(np.arange(X_vis.shape[0]), idx_resampled)
reduction_str = ('Reduced {:.2f}%'.format(
100 * (1 - float(len(X_resampled)) / len(X))))
print(reduction_str)
ax3.scatter(X_vis[idx_samples_removed, 0],
X_vis[idx_samples_removed, 1],
alpha=.2,
label='Removed samples',
c='g')
plot_resampling(ax3, X_res_vis, y_resampled, 'RENN - ' + reduction_str)
# Apply the AllKNN
print('AllKNN')
allknn = AllKNN(return_indices=True)
X_resampled, y_resampled, idx_resampled = allknn.fit_resample(X, y)
X_res_vis = pca.transform(X_resampled)
idx_samples_removed = np.setdiff1d(np.arange(X_vis.shape[0]), idx_resampled)
reduction_str = ('Reduced {:.2f}%'.format(
100 * (1 - float(len(X_resampled)) / len(X))))
print(reduction_str)
ax4.scatter(X_vis[idx_samples_removed, 0],
X_vis[idx_samples_removed, 1],
alpha=.2,
label='Removed samples',
c='g')
plot_resampling(ax4, X_res_vis, y_resampled, 'All-KNN - ' + reduction_str)
plt.figlegend((c0, c1, c3), ('Class #0', 'Class #1', 'Removed samples'),
loc='lower center',
ncol=3,
# summarize class distribution
print(Counter(y))
# define undersampling strategy
under = RandomUnderSampler(sampling_strategy={0: 500, 1: 500})
# fit and apply the transform
X, y = under.fit_resample(X, y)
# summarize class distribution
print(Counter(y))
# advanced undersampling ======================================================
''' ALLKNN '''
from imblearn.under_sampling import AllKNN, NeighbourhoodCleaningRule
# define undersampling strategy
under_allknn = AllKNN()
# fit and apply the transform
X, y = under_allknn.fit_resample(X, y)
# summarize class distribution
print(Counter(y))
''' RENN '''
from imblearn.under_sampling import CondensedNearestNeighbour, EditedNearestNeighbours, RepeatedEditedNearestNeighbours
# define undersampling strategy
under_renn = RepeatedEditedNearestNeighbours()
# fit and apply the transform
X, y = under_renn.fit_resample(X, y)
# summarize class distribution
print(Counter(y))
# advanced oversampling =======================================================
''' ADASYN '''
from imblearn.over_sampling import ADASYN
# define oversampling strategy
import numpy as np
from common.import_data import ImportData
from collections import Counter
from imblearn.under_sampling import AllKNN
if __name__ == "__main__":
data_set = ImportData()
x: np.ndarray = data_set.import_all_data()
y: np.ndarray = data_set.import_columns(np.array(['Class'])).ravel()
print('Original dataset shape %s' % Counter(y))
allknn = AllKNN()
x_res, y_res = allknn.fit_resample(x, y)
print('Reduced dataset shape %s' % Counter(y_res))
def resampling_assigner(imb_technique, AA_ova_X_train, AA_ova_y_train,
AI_ova_X_train, AI_ova_y_train, AW_ova_X_train,
AW_ova_y_train, CC_ova_X_train, CC_ova_y_train,
QA_ova_X_train, QA_ova_y_train):
print(imb_technique)
if imb_technique == "ADASYN":
AA_ada, AI_ada, AW_ada, CC_ada, QA_ada = ADASYN(), ADASYN(), ADASYN(
), ADASYN(), ADASYN()
AA_X_res, AA_y_res = AA_ada.fit_resample(AA_ova_X_train,
AA_ova_y_train)
AI_X_res, AI_y_res = AI_ada.fit_resample(AI_ova_X_train,
AI_ova_y_train)
AW_X_res, AW_y_res = AW_ada.fit_resample(AW_ova_X_train,
AW_ova_y_train)
CC_X_res, CC_y_res = CC_ada.fit_resample(CC_ova_X_train,
CC_ova_y_train)
QA_X_res, QA_y_res = QA_ada.fit_resample(QA_ova_X_train,
QA_ova_y_train)
elif imb_technique == "ALLKNN":
AA_allknn, AI_allknn, AW_allknn, CC_allknn, QA_allknn = AllKNN(
), AllKNN(), AllKNN(), AllKNN(), AllKNN()
AA_X_res, AA_y_res = AA_allknn.fit_resample(AA_ova_X_train,
AA_ova_y_train)
AI_X_res, AI_y_res = AI_allknn.fit_resample(AI_ova_X_train,
AI_ova_y_train)
AW_X_res, AW_y_res = AW_allknn.fit_resample(AW_ova_X_train,
AW_ova_y_train)
CC_X_res, CC_y_res = CC_allknn.fit_resample(CC_ova_X_train,
CC_ova_y_train)
QA_X_res, QA_y_res = QA_allknn.fit_resample(QA_ova_X_train,
QA_ova_y_train)
elif imb_technique == "CNN":
AA_cnn, AI_cnn, AW_cnn, CC_cnn, QA_cnn = CondensedNearestNeighbour(
), CondensedNearestNeighbour(), CondensedNearestNeighbour(
), CondensedNearestNeighbour(), CondensedNearestNeighbour()
AA_X_res, AA_y_res = AA_cnn.fit_resample(AA_ova_X_train,
AA_ova_y_train)
AI_X_res, AI_y_res = AI_cnn.fit_resample(AI_ova_X_train,
AI_ova_y_train)
AW_X_res, AW_y_res = AW_cnn.fit_resample(AW_ova_X_train,
AW_ova_y_train)
CC_X_res, CC_y_res = CC_cnn.fit_resample(CC_ova_X_train,
CC_ova_y_train)
QA_X_res, QA_y_res = QA_cnn.fit_resample(QA_ova_X_train,
QA_ova_y_train)
elif imb_technique == "ENN":
AA_enn, AI_enn, AW_enn, CC_enn, QA_enn = EditedNearestNeighbours(
), EditedNearestNeighbours(), EditedNearestNeighbours(
), EditedNearestNeighbours(), EditedNearestNeighbours()
AA_X_res, AA_y_res = AA_enn.fit_resample(AA_ova_X_train,
AA_ova_y_train)
AI_X_res, AI_y_res = AI_enn.fit_resample(AI_ova_X_train,
AI_ova_y_train)
AW_X_res, AW_y_res = AW_enn.fit_resample(AW_ova_X_train,
AW_ova_y_train)
CC_X_res, CC_y_res = CC_enn.fit_resample(CC_ova_X_train,
CC_ova_y_train)
QA_X_res, QA_y_res = QA_enn.fit_resample(QA_ova_X_train,
QA_ova_y_train)
elif imb_technique == "IHT":
AA_iht, AI_iht, AW_iht, CC_iht, QA_iht = InstanceHardnessThreshold(
), InstanceHardnessThreshold(), InstanceHardnessThreshold(
), InstanceHardnessThreshold(), InstanceHardnessThreshold()
AA_X_res, AA_y_res = AA_iht.fit_resample(AA_ova_X_train,
AA_ova_y_train)
AI_X_res, AI_y_res = AI_iht.fit_resample(AI_ova_X_train,
AI_ova_y_train)
AW_X_res, AW_y_res = AW_iht.fit_resample(AW_ova_X_train,
AW_ova_y_train)
CC_X_res, CC_y_res = CC_iht.fit_resample(CC_ova_X_train,
CC_ova_y_train)
QA_X_res, QA_y_res = QA_iht.fit_resample(QA_ova_X_train,
QA_ova_y_train)
elif imb_technique == "NCR":
AA_ncr, AI_ncr, AW_ncr, CC_ncr, QA_ncr = NeighbourhoodCleaningRule(
), NeighbourhoodCleaningRule(), NeighbourhoodCleaningRule(
), NeighbourhoodCleaningRule(), NeighbourhoodCleaningRule()
AA_ova_y_train = [
0 if i == "Accepted/Assigned" else 1 for i in AA_ova_y_train
]
AA_X_res, AA_y_res = AA_ncr.fit_resample(AA_ova_X_train,
AA_ova_y_train)
AI_ova_y_train = [
0 if i == "Accepted/In Progress" else 1 for i in AI_ova_y_train
]
AI_X_res, AI_y_res = AI_ncr.fit_resample(AI_ova_X_train,
AI_ova_y_train)
AW_ova_y_train = [
0 if i == "Accepted/Wait" else 1 for i in AW_ova_y_train
]
AW_X_res, AW_y_res = AW_ncr.fit_resample(AW_ova_X_train,
AW_ova_y_train)
CC_ova_y_train = [
0 if i == "Completed/Closed" else 1 for i in CC_ova_y_train
]
CC_X_res, CC_y_res = CC_ncr.fit_resample(CC_ova_X_train,
CC_ova_y_train)
QA_ova_y_train = [
0 if i == "Queued/Awaiting Assignment" else 1
for i in QA_ova_y_train
]
QA_X_res, QA_y_res = QA_ncr.fit_resample(QA_ova_X_train,
QA_ova_y_train)
elif imb_technique == "NM":
AA_nm, AI_nm, AW_nm, CC_nm, QA_nm = NearMiss(), NearMiss(), NearMiss(
), NearMiss(), NearMiss()
AA_X_res, AA_y_res = AA_nm.fit_resample(AA_ova_X_train, AA_ova_y_train)
AI_X_res, AI_y_res = AI_nm.fit_resample(AI_ova_X_train, AI_ova_y_train)
AW_X_res, AW_y_res = AW_nm.fit_resample(AW_ova_X_train, AW_ova_y_train)
CC_X_res, CC_y_res = CC_nm.fit_resample(CC_ova_X_train, CC_ova_y_train)
QA_X_res, QA_y_res = QA_nm.fit_resample(QA_ova_X_train, QA_ova_y_train)
elif imb_technique == "OSS":
AA_oss, AI_oss, AW_oss, CC_oss, QA_oss = OneSidedSelection(
), OneSidedSelection(), OneSidedSelection(), OneSidedSelection(
), OneSidedSelection()
AA_X_res, AA_y_res = AA_oss.fit_resample(AA_ova_X_train,
AA_ova_y_train)
AI_X_res, AI_y_res = AI_oss.fit_resample(AI_ova_X_train,
AI_ova_y_train)
AW_X_res, AW_y_res = AW_oss.fit_resample(AW_ova_X_train,
AW_ova_y_train)
CC_X_res, CC_y_res = CC_oss.fit_resample(CC_ova_X_train,
CC_ova_y_train)
QA_X_res, QA_y_res = QA_oss.fit_resample(QA_ova_X_train,
QA_ova_y_train)
elif imb_technique == "RENN":
AA_renn, AI_renn, AW_renn, CC_renn, QA_renn = RepeatedEditedNearestNeighbours(
), RepeatedEditedNearestNeighbours(), RepeatedEditedNearestNeighbours(
), RepeatedEditedNearestNeighbours(), RepeatedEditedNearestNeighbours(
)
AA_X_res, AA_y_res = AA_renn.fit_resample(AA_ova_X_train,
AA_ova_y_train)
AI_X_res, AI_y_res = AI_renn.fit_resample(AI_ova_X_train,
AI_ova_y_train)
AW_X_res, AW_y_res = AW_renn.fit_resample(AW_ova_X_train,
AW_ova_y_train)
CC_X_res, CC_y_res = CC_renn.fit_resample(CC_ova_X_train,
CC_ova_y_train)
QA_X_res, QA_y_res = QA_renn.fit_resample(QA_ova_X_train,
QA_ova_y_train)
elif imb_technique == "SMOTE":
AA_sm, AI_sm, AW_sm, CC_sm, QA_sm = SMOTE(), SMOTE(), SMOTE(), SMOTE(
), SMOTE()
AA_X_res, AA_y_res = AA_sm.fit_resample(AA_ova_X_train, AA_ova_y_train)
AI_X_res, AI_y_res = AI_sm.fit_resample(AI_ova_X_train, AI_ova_y_train)
AW_X_res, AW_y_res = AW_sm.fit_resample(AW_ova_X_train, AW_ova_y_train)
CC_X_res, CC_y_res = CC_sm.fit_resample(CC_ova_X_train, CC_ova_y_train)
QA_X_res, QA_y_res = QA_sm.fit_resample(QA_ova_X_train, QA_ova_y_train)
elif imb_technique == "BSMOTE":
AA_bsm, AI_bsm, AW_bsm, CC_bsm, QA_bsm = BorderlineSMOTE(
), BorderlineSMOTE(), BorderlineSMOTE(), BorderlineSMOTE(
), BorderlineSMOTE()
AA_X_res, AA_y_res = AA_bsm.fit_resample(AA_ova_X_train,
AA_ova_y_train)
AI_X_res, AI_y_res = AI_bsm.fit_resample(AI_ova_X_train,
AI_ova_y_train)
AW_X_res, AW_y_res = AW_bsm.fit_resample(AW_ova_X_train,
AW_ova_y_train)
CC_X_res, CC_y_res = CC_bsm.fit_resample(CC_ova_X_train,
CC_ova_y_train)
QA_X_res, QA_y_res = QA_bsm.fit_resample(QA_ova_X_train,
QA_ova_y_train)
elif imb_technique == "SMOTEENN":
AA_smenn, AI_smenn, AW_smenn, CC_smenn, QA_smenn = SMOTEENN(
), SMOTEENN(), SMOTEENN(), SMOTEENN(), SMOTEENN()
AA_X_res, AA_y_res = AA_smenn.fit_resample(AA_ova_X_train,
AA_ova_y_train)
AI_X_res, AI_y_res = AI_smenn.fit_resample(AI_ova_X_train,
AI_ova_y_train)
AW_X_res, AW_y_res = AW_smenn.fit_resample(AW_ova_X_train,
AW_ova_y_train)
CC_X_res, CC_y_res = CC_smenn.fit_resample(CC_ova_X_train,
CC_ova_y_train)
QA_X_res, QA_y_res = QA_smenn.fit_resample(QA_ova_X_train,
QA_ova_y_train)
elif imb_technique == "SMOTETOMEK":
AA_smtm, AI_smtm, AW_smtm, CC_smtm, QA_smtm = SMOTETomek(), SMOTETomek(
), SMOTETomek(), SMOTETomek(), SMOTETomek()
AA_X_res, AA_y_res = AA_smtm.fit_resample(AA_ova_X_train,
AA_ova_y_train)
AI_X_res, AI_y_res = AI_smtm.fit_resample(AI_ova_X_train,
AI_ova_y_train)
AW_X_res, AW_y_res = AW_smtm.fit_resample(AW_ova_X_train,
AW_ova_y_train)
CC_X_res, CC_y_res = CC_smtm.fit_resample(CC_ova_X_train,
CC_ova_y_train)
QA_X_res, QA_y_res = QA_smtm.fit_resample(QA_ova_X_train,
QA_ova_y_train)
elif imb_technique == "TOMEK":
AA_tm, AI_tm, AW_tm, CC_tm, QA_tm = TomekLinks(), TomekLinks(
), TomekLinks(), TomekLinks(), TomekLinks()
AA_X_res, AA_y_res = AA_tm.fit_resample(AA_ova_X_train, AA_ova_y_train)
AI_X_res, AI_y_res = AI_tm.fit_resample(AI_ova_X_train, AI_ova_y_train)
AW_X_res, AW_y_res = AW_tm.fit_resample(AW_ova_X_train, AW_ova_y_train)
CC_X_res, CC_y_res = CC_tm.fit_resample(CC_ova_X_train, CC_ova_y_train)
QA_X_res, QA_y_res = QA_tm.fit_resample(QA_ova_X_train, QA_ova_y_train)
elif imb_technique == "ROS":
AA_ros, AI_ros, AW_ros, CC_ros, QA_ros = RandomOverSampler(
), RandomOverSampler(), RandomOverSampler(), RandomOverSampler(
), RandomOverSampler()
AA_X_res, AA_y_res = AA_ros.fit_resample(AA_ova_X_train,
AA_ova_y_train)
AI_X_res, AI_y_res = AI_ros.fit_resample(AI_ova_X_train,
AI_ova_y_train)
AW_X_res, AW_y_res = AW_ros.fit_resample(AW_ova_X_train,
AW_ova_y_train)
CC_X_res, CC_y_res = CC_ros.fit_resample(CC_ova_X_train,
CC_ova_y_train)
QA_X_res, QA_y_res = QA_ros.fit_resample(QA_ova_X_train,
QA_ova_y_train)
elif imb_technique == "RUS":
AA_rus, AI_rus, AW_rus, CC_rus, QA_rus = RandomUnderSampler(
), RandomUnderSampler(), RandomUnderSampler(), RandomUnderSampler(
), RandomUnderSampler()
AA_X_res, AA_y_res = AA_rus.fit_resample(AA_ova_X_train,
AA_ova_y_train)
AI_X_res, AI_y_res = AI_rus.fit_resample(AI_ova_X_train,
AI_ova_y_train)
AW_X_res, AW_y_res = AW_rus.fit_resample(AW_ova_X_train,
AW_ova_y_train)
CC_X_res, CC_y_res = CC_rus.fit_resample(CC_ova_X_train,
CC_ova_y_train)
QA_X_res, QA_y_res = QA_rus.fit_resample(QA_ova_X_train,
QA_ova_y_train)
return AA_X_res, AA_y_res, AI_X_res, AI_y_res, AW_X_res, AW_y_res, CC_X_res, CC_y_res, QA_X_res, QA_y_res
def aiiknn(X, y):
allknn = AllKNN()
X_res, y_res = allknn.fit_resample(X, y)
return X_res, y_res
#sns.countplot(x=target, data=under_sample)
#plt.show()
X = df.loc[:, df.columns!=target]
Y = df.loc[:, df.columns==target]
#print(X)
#print(Y)
#nr = NearMiss(version=3, n_neighbors=3)
#nr = ClusterCentroids()
#nr = TomekLinks()
#nr = RandomUnderSampler()
#nr = NeighbourhoodCleaningRule(n_neighbors=3)
#nr = CondensedNearestNeighbour(n_neighbors=3)
nr = AllKNN()
#nr = OneSidedSelection(n_neighbors=3)
#nr = EditedNearestNeighbours(n_neighbors=3)
X_train_miss, Y_train_miss = nr.fit_resample(X, Y)
X_train, X_test, Y_train, Y_test = train_test_split(X_train_miss, Y_train_miss, test_size=0.33, random_state=0)
#clf2 = KNeighborsClassifier(n_neighbors=3)
clf1 = LogisticRegression()
clf2 = DecisionTreeClassifier()
#clf2 = RandomForestClassifier(n_estimators=20, random_state=0)
clf3 = GaussianNB()
#clf3 = MultinomialNB()
#evc = BaggingClassifier(clf1, n_estimators=10, random_state=0)
evc = VotingClassifier(estimators=[('lr', clf1), ('dt', clf2), ('nb', clf3)], voting='hard')
#evc = AdaBoostClassifier(n_estimators=50, base_estimator=clf3, learning_rate=1)
result = evc.fit(X_train, np.ravel(Y_train))
Y_Test_Pred = result.predict(X_test)
#print(evc.score(X_test,np.ravel(Y_test)))
def test_deprecation_random_state():
allknn = AllKNN(random_state=0)
with warns(
DeprecationWarning, match="'random_state' is deprecated from 0.4"):
allknn.fit_resample(X, Y)
def test_alknn_not_good_object():
nn = 'rnd'
allknn = AllKNN(n_neighbors=nn, kind_sel='mode')
with raises(ValueError):
allknn.fit_resample(X, Y)
def resampling_assigner(imb_technique, AP_ova_X_train, AP_ova_y_train,
PM_ova_X_train, PM_ova_y_train, SC_ova_X_train,
SC_ova_y_train):
print(imb_technique)
if imb_technique == "ADASYN":
AP_ada, PM_ada, SC_ada = ADASYN(), ADASYN(), ADASYN()
AP_X_res, AP_y_res = AP_ada.fit_resample(AP_ova_X_train,
AP_ova_y_train)
PM_X_res, PM_y_res = PM_ada.fit_resample(PM_ova_X_train,
PM_ova_y_train)
SC_X_res, SC_y_res = SC_ada.fit_resample(SC_ova_X_train,
SC_ova_y_train)
elif imb_technique == "ALLKNN":
AP_allknn, PM_allknn, SC_allknn = AllKNN(), AllKNN(), AllKNN()
AP_X_res, AP_y_res = AP_allknn.fit_resample(AP_ova_X_train,
AP_ova_y_train)
PM_X_res, PM_y_res = PM_allknn.fit_resample(PM_ova_X_train,
PM_ova_y_train)
SC_X_res, SC_y_res = SC_allknn.fit_resample(SC_ova_X_train,
SC_ova_y_train)
elif imb_technique == "CNN":
AP_cnn, PM_cnn, SC_cnn = CondensedNearestNeighbour(
), CondensedNearestNeighbour(), CondensedNearestNeighbour()
AP_X_res, AP_y_res = AP_cnn.fit_resample(AP_ova_X_train,
AP_ova_y_train)
PM_X_res, PM_y_res = PM_cnn.fit_resample(PM_ova_X_train,
PM_ova_y_train)
SC_X_res, SC_y_res = SC_cnn.fit_resample(SC_ova_X_train,
SC_ova_y_train)
elif imb_technique == "ENN":
AP_enn, PM_enn, SC_enn = EditedNearestNeighbours(
), EditedNearestNeighbours(), EditedNearestNeighbours()
AP_X_res, AP_y_res = AP_enn.fit_resample(AP_ova_X_train,
AP_ova_y_train)
PM_X_res, PM_y_res = PM_enn.fit_resample(PM_ova_X_train,
PM_ova_y_train)
SC_X_res, SC_y_res = SC_enn.fit_resample(SC_ova_X_train,
SC_ova_y_train)
elif imb_technique == "IHT":
AP_iht, PM_iht, SC_iht = InstanceHardnessThreshold(
), InstanceHardnessThreshold(), InstanceHardnessThreshold()
AP_X_res, AP_y_res = AP_iht.fit_resample(AP_ova_X_train,
AP_ova_y_train)
PM_X_res, PM_y_res = PM_iht.fit_resample(PM_ova_X_train,
PM_ova_y_train)
SC_X_res, SC_y_res = SC_iht.fit_resample(SC_ova_X_train,
SC_ova_y_train)
elif imb_technique == "NCR":
AP_iht, PM_iht, SC_iht = NeighbourhoodCleaningRule(
), NeighbourhoodCleaningRule(), NeighbourhoodCleaningRule()
AP_ova_y_train = [
0 if i == "Add penalty" else 1 for i in AP_ova_y_train
]
AP_X_res, AP_y_res = AP_ncr.fit_resample(AP_ova_X_train,
AP_ova_y_train)
PM_ova_y_train = [0 if i == "Payment" else 1 for i in PM_ova_y_train]
PM_X_res, PM_y_res = PM_ncr.fit_resample(PM_ova_X_train,
PM_ova_y_train)
SC_ova_y_train = [
0 if i == "Send for Credit Collection" else 1
for i in SC_ova_y_train
]
SC_X_res, SC_y_res = SC_ncr.fit_resample(SC_ova_X_train,
SC_ova_y_train)
elif imb_technique == "NM":
AP_nm, PM_nm, SC_nm = NearMiss(), NearMiss(), NearMiss()
AP_X_res, AP_y_res = AP_nm.fit_resample(AP_ova_X_train, AP_ova_y_train)
PM_X_res, PM_y_res = PM_nm.fit_resample(PM_ova_X_train, PM_ova_y_train)
SC_X_res, SC_y_res = SC_nm.fit_resample(SC_ova_X_train, SC_ova_y_train)
elif imb_technique == "OSS":
AP_oss, PM_oss, SC_oss = OneSidedSelection(), OneSidedSelection(
), OneSidedSelection()
AP_X_res, AP_y_res = AP_oss.fit_resample(AP_ova_X_train,
AP_ova_y_train)
PM_X_res, PM_y_res = PM_oss.fit_resample(PM_ova_X_train,
PM_ova_y_train)
SC_X_res, SC_y_res = SC_oss.fit_resample(SC_ova_X_train,
SC_ova_y_train)
elif imb_technique == "RENN":
AP_renn, PM_renn, SC_renn = RepeatedEditedNearestNeighbours(
), RepeatedEditedNearestNeighbours(), RepeatedEditedNearestNeighbours(
)
AP_X_res, AP_y_res = AP_renn.fit_resample(AP_ova_X_train,
AP_ova_y_train)
PM_X_res, PM_y_res = PM_renn.fit_resample(PM_ova_X_train,
PM_ova_y_train)
SC_X_res, SC_y_res = SC_renn.fit_resample(SC_ova_X_train,
SC_ova_y_train)
elif imb_technique == "SMOTE":
AP_sm, PM_sm, SC_sm = SMOTE(), SMOTE(), SMOTE()
AP_X_res, AP_y_res = AP_sm.fit_resample(AP_ova_X_train, AP_ova_y_train)
PM_X_res, PM_y_res = PM_sm.fit_resample(PM_ova_X_train, PM_ova_y_train)
SC_X_res, SC_y_res = SC_sm.fit_resample(SC_ova_X_train, SC_ova_y_train)
elif imb_technique == "BSMOTE":
AP_bsm, PM_bsm, SC_bsm = BorderlineSMOTE(), BorderlineSMOTE(
), BorderlineSMOTE()
AP_X_res, AP_y_res = AP_bsm.fit_resample(AP_ova_X_train,
AP_ova_y_train)
PM_X_res, PM_y_res = PM_bsm.fit_resample(PM_ova_X_train,
PM_ova_y_train)
SC_X_res, SC_y_res = SC_bsm.fit_resample(SC_ova_X_train,
SC_ova_y_train)
elif imb_technique == "SMOTEENN":
AP_smenn, PM_smenn, SC_smenn = SMOTEENN(), SMOTEENN(), SMOTEENN()
AP_X_res, AP_y_res = AP_smenn.fit_resample(AP_ova_X_train,
AP_ova_y_train)
PM_X_res, PM_y_res = PM_smenn.fit_resample(PM_ova_X_train,
PM_ova_y_train)
SC_X_res, SC_y_res = SC_smenn.fit_resample(SC_ova_X_train,
SC_ova_y_train)
elif imb_technique == "SMOTETOMEK":
AP_smtm, PM_smtm, SC_smtm = SMOTETomek(), SMOTETomek(), SMOTETomek()
AP_X_res, AP_y_res = AP_smtm.fit_resample(AP_ova_X_train,
AP_ova_y_train)
PM_X_res, PM_y_res = PM_smtm.fit_resample(PM_ova_X_train,
PM_ova_y_train)
SC_X_res, SC_y_res = SC_smtm.fit_resample(SC_ova_X_train,
SC_ova_y_train)
elif imb_technique == "TOMEK":
AP_tm, PM_tm, SC_tm = TomekLinks(), TomekLinks(), TomekLinks()
AP_X_res, AP_y_res = AP_tm.fit_resample(AP_ova_X_train, AP_ova_y_train)
PM_X_res, PM_y_res = PM_tm.fit_resample(PM_ova_X_train, PM_ova_y_train)
SC_X_res, SC_y_res = SC_tm.fit_resample(SC_ova_X_train, SC_ova_y_train)
elif imb_technique == "ROS":
AP_ros, PM_ros, SC_ros = RandomOverSampler(), RandomOverSampler(
), RandomOverSampler()
AP_X_res, AP_y_res = AP_ros.fit_resample(AP_ova_X_train,
AP_ova_y_train)
PM_X_res, PM_y_res = PM_ros.fit_resample(PM_ova_X_train,
PM_ova_y_train)
SC_X_res, SC_y_res = SC_ros.fit_resample(SC_ova_X_train,
SC_ova_y_train)
elif imb_technique == "RUS":
AP_rus, PM_rus, SC_rus = RandomUnderSampler(), RandomUnderSampler(
), RandomUnderSampler()
AP_X_res, AP_y_res = AP_rus.fit_resample(AP_ova_X_train,
AP_ova_y_train)
PM_X_res, PM_y_res = PM_rus.fit_resample(PM_ova_X_train,
PM_ova_y_train)
SC_X_res, SC_y_res = SC_rus.fit_resample(SC_ova_X_train,
SC_ova_y_train)
return AP_X_res, AP_y_res, PM_X_res, PM_y_res, SC_X_res, SC_y_res
def all_imblearn(xx, yy):
imblearnlist = []
"""OVER SAMPLING"""
"""Random Over Sampler"""
ros = RandomOverSampler(random_state=0)
X_resampled, y_resampled = ros.fit_resample(xx, yy)
randomOverSampler = [X_resampled, y_resampled, 'random over sampler']
imblearnlist.append(randomOverSampler)
"""SMOTE"""
X_resampled, y_resampled = SMOTE().fit_resample(xx, yy)
smote = [X_resampled, y_resampled, 'smote']
imblearnlist.append(smote)
"""SMOTE borderline1"""
sm = SMOTE(kind='borderline1')
X_resampled, y_resampled = sm.fit_resample(xx, yy)
smote = [X_resampled, y_resampled, 'smote borderline1']
imblearnlist.append(smote)
"""SMOTE borderline2"""
sm = SMOTE(kind='borderline2')
X_resampled, y_resampled = sm.fit_resample(xx, yy)
smote = [X_resampled, y_resampled, 'smote borderline2']
imblearnlist.append(smote)
"""SMOTE svm"""
sm = SMOTE(kind='svm')
X_resampled, y_resampled = sm.fit_resample(xx, yy)
smote = [X_resampled, y_resampled, 'smote svm']
imblearnlist.append(smote)
"""SMOTENC"""
smote_nc = SMOTENC(categorical_features=[0, 2], random_state=0)
X_resampled, y_resampled = smote_nc.fit_resample(xx, yy)
smote = [X_resampled, y_resampled, 'smotenc']
imblearnlist.append(smote)
# """ADASYN"""
# X_resampled, y_resampled = ADASYN.fit_resample(xx, yy)
# adasyn = [X_resampled, y_resampled, 'adasyn']
# imblearnlist.append(adasyn)
#
"""UNDER SAMPLING"""
"""Cluster Centroids"""
cc = ClusterCentroids(random_state=0)
X_resampled, y_resampled = cc.fit_resample(xx, yy)
reSampled = [X_resampled, y_resampled, 'cluster centroids']
imblearnlist.append(reSampled)
"""Random Over Sampler"""
rus = RandomUnderSampler(random_state=0)
X_resampled, y_resampled = rus.fit_resample(xx, yy)
reSampled = [X_resampled, y_resampled, 'random under sampler']
imblearnlist.append(reSampled)
"""Near Miss 1"""
nm1 = NearMiss(version=1)
X_resampled, y_resampled = nm1.fit_resample(xx, yy)
reSampled = [X_resampled, y_resampled, 'near miss 1']
imblearnlist.append(reSampled)
"""Near Miss 2"""
nm2 = NearMiss(version=2)
X_resampled, y_resampled = nm2.fit_resample(xx, yy)
reSampled = [X_resampled, y_resampled, 'near miss 2']
imblearnlist.append(reSampled)
"""Near Miss 3"""
nm3 = NearMiss(version=3)
X_resampled, y_resampled = nm3.fit_resample(xx, yy)
reSampled = [X_resampled, y_resampled, 'near miss 3']
imblearnlist.append(reSampled)
"""Edited Nearest Neighbours"""
enn = EditedNearestNeighbours()
X_resampled, y_resampled = enn.fit_resample(xx, yy)
reSampled = [X_resampled, y_resampled, 'edited nearest neighbours']
imblearnlist.append(reSampled)
"""Repeated Edited Nearest Neighbours"""
renn = RepeatedEditedNearestNeighbours()
X_resampled, y_resampled = renn.fit_resample(xx, yy)
reSampled = [X_resampled, y_resampled, 'repeated edited nearest neighbours']
imblearnlist.append(reSampled)
"""All KNN"""
allknn = AllKNN()
X_resampled, y_resampled = allknn.fit_resample(xx, yy)
reSampled = [X_resampled, y_resampled, 'allKNN']
imblearnlist.append(reSampled)
"""Condensed Nearest Neighbour"""
cnn = CondensedNearestNeighbour(random_state=0)
X_resampled, y_resampled = cnn.fit_resample(xx, yy)
reSampled = [X_resampled, y_resampled, 'Condensed Nearest Neighbour']
imblearnlist.append(reSampled)
"""One Sided Selection"""
oss = OneSidedSelection(random_state=0)
X_resampled, y_resampled = oss.fit_resample(xx, yy)
reSampled = [X_resampled, y_resampled, 'One Sided Selection']
imblearnlist.append(reSampled)
"""Neighbourhood Cleaning Rule"""
ncr = NeighbourhoodCleaningRule()
X_resampled, y_resampled = ncr.fit_resample(xx, yy)
reSampled = [X_resampled, y_resampled, 'Neighbourhood Cleaning Rule']
imblearnlist.append(reSampled)
"""OVER AND UNDER SAMPLING"""
"""SMOTEENN"""
smote_enn = SMOTEENN(random_state=0)
X_resampled, y_resampled = smote_enn.fit_resample(xx, yy)
reSampled = [X_resampled, y_resampled, 'SMOTEENN']
imblearnlist.append(reSampled)
"""SMOTETomek"""
smote_tomek = SMOTETomek(random_state=0)
X_resampled, y_resampled = smote_tomek.fit_resample(xx, yy)
reSampled = [X_resampled, y_resampled, 'SMOTETomek']
imblearnlist.append(reSampled)
return imblearnlist
def test_alknn_not_good_object():
nn = "rnd"
allknn = AllKNN(n_neighbors=nn, kind_sel="mode")
with pytest.raises(ValueError):
allknn.fit_resample(X, Y)
